@principal-ai/logo-component 0.1.3 → 0.1.5

package/dist/esm/MazeDemoNew.js

@@ -0,0 +1,339 @@
+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/SquareLogo.js

@@ -0,0 +1,50 @@
+import React from 'react';
+export const SquareLogo = ({ width = 150, height = 150, colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#FFA07A', '#96CEB4', '#FFEAA7', '#DDA15E', '#BC6C25', '#E76F51'], opacity = 0.9, }) => {
+    const rectangleStyle = {
+        transition: 'all 0.3s ease',
+    };
+    return (React.createElement("svg", { width: width, height: height, viewBox: "0 0 100 100", xmlns: "http://www.w3.org/2000/svg", style: { opacity } },
+        React.createElement("defs", null,
+            React.createElement("filter", { id: "glow" },
+                React.createElement("feGaussianBlur", { stdDeviation: "1.5", result: "coloredBlur" }),
+                React.createElement("feMerge", null,
+                    React.createElement("feMergeNode", { in: "coloredBlur" }),
+                    React.createElement("feMergeNode", { in: "SourceGraphic" })))),
+        React.createElement("rect", { x: "10", y: "10", width: "10", height: "15", fill: colors[1], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite" })),
+        React.createElement("rect", { x: "20", y: "10", width: "15", height: "80", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "0.3s" })),
+        React.createElement("rect", { x: "35", y: "10", width: "30", height: "12", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "0.6s" })),
+        React.createElement("rect", { x: "65", y: "10", width: "25", height: "12", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "0.9s" })),
+        React.createElement("rect", { x: "35", y: "22", width: "15", height: "18", fill: colors[3], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "1.2s" })),
+        React.createElement("rect", { x: "50", y: "22", width: "15", height: "18", fill: colors[4], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "1.5s" })),
+        React.createElement("rect", { x: "65", y: "22", width: "12", height: "18", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "1.8s" })),
+        React.createElement("rect", { x: "77", y: "22", width: "13", height: "28", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "2.1s" })),
+        React.createElement("rect", { x: "77", y: "50", width: "13", height: "40", fill: colors[5], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "2.1s" })),
+        React.createElement("rect", { x: "35", y: "40", width: "55", height: "10", fill: colors[0], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "2.4s" })),
+        React.createElement("rect", { x: "10", y: "25", width: "10", height: "35", fill: colors[6], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "2.7s" })),
+        React.createElement("rect", { x: "35", y: "50", width: "20", height: "20", fill: colors[7], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "0.3s" })),
+        React.createElement("rect", { x: "55", y: "50", width: "22", height: "20", fill: colors[8], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "0.6s" })),
+        React.createElement("rect", { x: "10", y: "60", width: "10", height: "30", fill: colors[1], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "0.9s" })),
+        React.createElement("rect", { x: "35", y: "70", width: "25", height: "20", fill: colors[2], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "1;0.8;1", dur: "3s", repeatCount: "indefinite", begin: "1.2s" })),
+        React.createElement("rect", { x: "60", y: "70", width: "17", height: "20", fill: colors[3], style: rectangleStyle, filter: "url(#glow)" },
+            React.createElement("animate", { attributeName: "opacity", values: "0.8;1;0.8", dur: "3s", repeatCount: "indefinite", begin: "1.5s" })),
+        React.createElement("line", { x1: "20", y1: "10", x2: "20", y2: "90", stroke: "rgba(255, 255, 255, 0.15)", strokeWidth: "0.5" }),
+        React.createElement("line", { x1: "35", y1: "10", x2: "35", y2: "90", stroke: "rgba(255, 255, 255, 0.15)", strokeWidth: "0.5" }),
+        React.createElement("line", { x1: "10", y1: "22", x2: "90", y2: "22", stroke: "rgba(255, 255, 255, 0.15)", strokeWidth: "0.5" }),
+        React.createElement("line", { x1: "10", y1: "40", x2: "90", y2: "40", stroke: "rgba(255, 255, 255, 0.15)", strokeWidth: "0.5" }),
+        React.createElement("line", { x1: "10", y1: "50", x2: "90", y2: "50", stroke: "rgba(255, 255, 255, 0.15)", strokeWidth: "0.5" })));
+};

package/dist/esm/WreathLogo.js

@@ -0,0 +1,85 @@
+import React from 'react';
+export const WreathLogo = ({ width = 150, height = 150, pColor = '#2C3E50', wreathColor = '#27AE60', leafAccentColor = '#52BE80', opacity = 0.9, animationSpeed = 3, }) => {
+    const wreathRadius = 58;
+    return (React.createElement("svg", { width: width, height: height, viewBox: "0 0 200 200", xmlns: "http://www.w3.org/2000/svg", style: { opacity } },
+        React.createElement("defs", null,
+            React.createElement("radialGradient", { id: "wreathGlow", cx: "50%", cy: "50%", r: "50%" },
+                React.createElement("stop", { offset: "0%", style: { stopColor: wreathColor, stopOpacity: 0.3 } }),
+                React.createElement("stop", { offset: "100%", style: { stopColor: wreathColor, stopOpacity: 0 } })),
+            React.createElement("filter", { id: "softGlow" },
+                React.createElement("feGaussianBlur", { stdDeviation: "2", result: "coloredBlur" }),
+                React.createElement("feMerge", null,
+                    React.createElement("feMergeNode", { in: "coloredBlur" }),
+                    React.createElement("feMergeNode", { in: "SourceGraphic" })))),
+        React.createElement("circle", { cx: "100", cy: "100", r: "70", fill: "url(#wreathGlow)", opacity: "0.3" }),
+        React.createElement("path", { d: (() => {
+                const numPoints = 24;
+                const waveAmplitude = 2;
+                let pathD = '';
+                const points = [];
+                // Generate all points first
+                for (let i = 0; i <= numPoints; i++) {
+                    const angle = (360 / numPoints) * i;
+                    const radians = (angle * Math.PI) / 180;
+                    // Use sine wave for smooth variation
+                    const radiusVariation = Math.sin((angle * Math.PI) / 180 * 6) * waveAmplitude;
+                    const currentRadius = wreathRadius + radiusVariation;
+                    const x = 100 + currentRadius * Math.cos(radians);
+                    const y = 100 + currentRadius * Math.sin(radians);
+                    points.push({ x, y, angle, radians });
+                }
+                // Create smooth cubic bezier path with better control points
+                pathD = `M ${points[0].x},${points[0].y}`;
+                for (let i = 0; i < points.length - 1; i++) {
+                    const current = points[i];
+                    const next = points[i + 1];
+                    // Calculate tangent for smooth curves
+                    const tangentLength = 0.4;
+                    const cp1x = current.x - Math.sin(current.radians) * tangentLength * 15;
+                    const cp1y = current.y + Math.cos(current.radians) * tangentLength * 15;
+                    const cp2x = next.x + Math.sin(next.radians) * tangentLength * 15;
+                    const cp2y = next.y - Math.cos(next.radians) * tangentLength * 15;
+                    pathD += ` C ${cp1x},${cp1y} ${cp2x},${cp2y} ${next.x},${next.y}`;
+                }
+                return pathD + ' Z';
+            })(), fill: "none", stroke: wreathColor, strokeWidth: "7", strokeLinecap: "round", strokeLinejoin: "round", opacity: "0.75", filter: "url(#softGlow)" },
+            React.createElement("animate", { attributeName: "stroke-opacity", values: "0.65;0.85;0.65", dur: `${animationSpeed}s`, repeatCount: "indefinite" })),
+        React.createElement("path", { d: (() => {
+                const numPoints = 24;
+                const waveAmplitude = 1.5;
+                const innerRadius = wreathRadius - 9;
+                let pathD = '';
+                const points = [];
+                for (let i = 0; i <= numPoints; i++) {
+                    const angle = (360 / numPoints) * i + 15; // Offset from main wreath
+                    const radians = (angle * Math.PI) / 180;
+                    // Use sine wave offset for smooth variation
+                    const radiusVariation = Math.sin(((angle + 30) * Math.PI) / 180 * 6) * waveAmplitude;
+                    const currentRadius = innerRadius + radiusVariation;
+                    const x = 100 + currentRadius * Math.cos(radians);
+                    const y = 100 + currentRadius * Math.sin(radians);
+                    points.push({ x, y, radians });
+                }
+                pathD = `M ${points[0].x},${points[0].y}`;
+                for (let i = 0; i < points.length - 1; i++) {
+                    const current = points[i];
+                    const next = points[i + 1];
+                    const tangentLength = 0.4;
+                    const cp1x = current.x - Math.sin(current.radians) * tangentLength * 15;
+                    const cp1y = current.y + Math.cos(current.radians) * tangentLength * 15;
+                    const cp2x = next.x + Math.sin(next.radians) * tangentLength * 15;
+                    const cp2y = next.y - Math.cos(next.radians) * tangentLength * 15;
+                    pathD += ` C ${cp1x},${cp1y} ${cp2x},${cp2y} ${next.x},${next.y}`;
+                }
+                return pathD + ' Z';
+            })(), fill: "none", stroke: leafAccentColor, strokeWidth: "5", strokeLinecap: "round", strokeLinejoin: "round", opacity: "0.6", filter: "url(#softGlow)" },
+            React.createElement("animate", { attributeName: "stroke-opacity", values: "0.5;0.7;0.5", dur: `${animationSpeed}s`, repeatCount: "indefinite", begin: "0.5s" })),
+        React.createElement("g", { filter: "url(#softGlow)" },
+            React.createElement("defs", null,
+                React.createElement("linearGradient", { id: "pGradient", x1: "0%", y1: "0%", x2: "0%", y2: "100%" },
+                    React.createElement("stop", { offset: "0%", style: { stopColor: pColor, stopOpacity: 1 } }),
+                    React.createElement("stop", { offset: "100%", style: { stopColor: pColor, stopOpacity: 0.85 } }))),
+            React.createElement("path", { d: "M 82,70\n             L 82,130\n             L 90,130\n             L 90,102\n             L 104,102\n             C 114,102 122,94 122,84\n             C 122,74 114,70 104,70\n             Z\n             M 90,78\n             L 104,78\n             C 109,78 114,80 114,84\n             C 114,88 109,94 104,94\n             L 90,94\n             Z", fill: "url(#pGradient)" },
+                React.createElement("animate", { attributeName: "opacity", values: "0.95;1;0.95", dur: `${animationSpeed}s`, repeatCount: "indefinite" })),
+            React.createElement("path", { d: "M 83,72 L 83,128 L 84,128 L 84,72 Z", fill: "white", opacity: "0.15" }))));
+};

package/dist/esm/index.js

@@ -1 +1,7 @@
 export { Logo } from './Logo';
+export { LogoSmall } from './LogoSmall';
+export { ForksLogo } from './ForksLogo';
+export { SquareLogo } from './SquareLogo';
+export { WreathLogo } from './WreathLogo';
+export { MazeDemo } from './MazeDemo';
+export { MazeDemoNew } from './MazeDemoNew';