@principal-ai/logo-component 0.1.4 → 0.1.5

package/dist/esm/utils/mazeGenerator.js

@@ -0,0 +1,266 @@
+/**
+ * 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/index.d.ts

@@ -1,3 +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';

package/dist/index.esm.js

@@ -1,3 +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';

package/dist/index.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForksLogo = exports.LogoSmall = exports.Logo = void 0;
+exports.MazeDemoNew = exports.MazeDemo = exports.WreathLogo = exports.SquareLogo = exports.ForksLogo = exports.LogoSmall = exports.Logo = void 0;
 var Logo_1 = require("./Logo");
 Object.defineProperty(exports, "Logo", { enumerable: true, get: function () { return Logo_1.Logo; } });
 var LogoSmall_1 = require("./LogoSmall");
 Object.defineProperty(exports, "LogoSmall", { enumerable: true, get: function () { return LogoSmall_1.LogoSmall; } });
 var ForksLogo_1 = require("./ForksLogo");
 Object.defineProperty(exports, "ForksLogo", { enumerable: true, get: function () { return ForksLogo_1.ForksLogo; } });
+var SquareLogo_1 = require("./SquareLogo");
+Object.defineProperty(exports, "SquareLogo", { enumerable: true, get: function () { return SquareLogo_1.SquareLogo; } });
+var WreathLogo_1 = require("./WreathLogo");
+Object.defineProperty(exports, "WreathLogo", { enumerable: true, get: function () { return WreathLogo_1.WreathLogo; } });
+var MazeDemo_1 = require("./MazeDemo");
+Object.defineProperty(exports, "MazeDemo", { enumerable: true, get: function () { return MazeDemo_1.MazeDemo; } });
+var MazeDemoNew_1 = require("./MazeDemoNew");
+Object.defineProperty(exports, "MazeDemoNew", { enumerable: true, get: function () { return MazeDemoNew_1.MazeDemoNew; } });

package/dist/utils/mazeGenerator.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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;

package/dist/utils/mazeGenerator.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * Maze Generator using Recursive Backtracking
+ * Creates a perfect maze (exactly one path between any two cells)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MazeGenerator = void 0;
+exports.generateMaze = generateMaze;
+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;
+        }
+    }
+}
+exports.MazeGenerator = MazeGenerator;
+/**
+ * Helper function to generate a maze with default settings
+ */
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principal-ai/logo-component",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Animated wireframe sphere logo component",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",