Breadth-first graph traversal in Typescript

bft.ts

/**
 * Given a start node and a function which provides an Iterable of adjacent nodes for any node,
 * perform a breadth-first traversal of the graph and yield each visited node together with
 * the minimum number of steps needed to reach that node from the start node.
 */
function *bft<T>(start: T, adjacent: (node: T) => Iterable<T>): IterableIterator<[T, number]> {
    const visited: Set<T> = new Set();
    const queue: T[] = [start];
    visited.add(start);
    var depth = 1;
    while (queue.length > 0) {
        const breadth = queue.length;
        for (let i=0; i<breadth; i++) {
            const next: T = queue.shift()!;
            for (let node of adjacent(next)) {
                if (!visited.has(node)) {
                    visited.add(node);
                    queue.push(node);
                    yield([node, depth]);
                }
            }
        }
        depth += 1;
    }
}

/**
 * Give a start node, a goal node, and a function which provides an Iterable of adjacent nodes for any node,
 * return the minimum number of steps needed to reach the goal node from the start node, or undefined if it
 * is unreachable.
 */
function getDepth<T>(start: T, goal: T, adjacent: (node: T) => Iterable<T>): number | undefined {
    for (let [node, depth] of bft(start, adjacent)) {
        if (node == goal) return depth;
    }
    return undefined;
}