Shortest Path in Binary Matrix

Problem statement

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

• All the visited cells of the path are 0.
• All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).

The length of a clear path is the number of visited cells of this path.

Example 1:

Input: grid = [[0,1],[1,0]]Output: 2

Example 2:

Input: grid = [[0,0,0],[1,1,0],[1,1,0]]Output: 4

Example 3:

Input: grid = [[1,0,0],[1,1,0],[1,1,0]]Output: -1

Constraints:

• n == grid.length
• n == grid[i].length
• 1 <= n <= 100
• grid[i][j] is 0 or 1

My solution

/**
 * @param {number[][]} grid
 * @return {number}
 */
var shortestPathBinaryMatrix = function(grid) {
    const n = grid.length - 1;
    
    const movements = [
        { x: 0, y: 1 },
        { x: 0, y: -1 },
        { y: 0, x: -1 },
        { y: 0, x: 1 },
        { x: 1, y: 1 },
        { x: 1, y: -1 },
        { y: 1, x: -1 },
        { y: -1, x: -1 },
    ]
    
    if (grid[n][n] === 1 || grid[0][0] === 1) {
        return -1
    }
    
    const queue = [{
        x: 0,
        y: 0,
        count: 1
    }]
    
    grid[0][0] = 1
    
    // let shorted = 
    
    while (queue.length) {
        // console.log(queue)
        const {x, y, count} = queue.shift()
        
        if (x === n && y === n) {
            return count
        } else {
            for (const {x: mayX, y: mayY} of movements) {
                const newX = mayX + x;
                const newY = mayY + y;
                
                // console.log(newX, newY)
                
                if (newX >= 0 && newY >= 0 && newX <= n && newY <= n && grid[newX][newY] === 0) {
                    queue.push({
                        x: newX,
                        y: newY,
                        count: count + 1
                    })
                    grid[newX][newY] = 1
                }
            }
        }
    }
    
    return -1;
};