TypeScript Generator Method

class DataStream {
    // T = number, TReturn = string, TNext = boolean
    *processStream(): Generator<number, string, boolean> {
        // Execution pauses here, yielding 1. 
        // The boolean passed to the next() call is assigned to 'condition'.
        const condition: boolean = yield 1; 
        
        if (condition) {
            yield 2;
        }
        
        return "Stream Complete";
    }
}

const literalGenerator = {
    *generateKeys(): Generator<string, void, unknown> {
        yield "key_1";
        yield "key_2";
    }
};

type IteratorResult<T, TReturn = any> = 
    | { done: false, value: T }
    | { done: true, value: TReturn };

const stream = new DataStream();
const iterator = stream.processStream(); // Method body has not executed yet

// Starts execution, runs to the first yield.
const step1 = iterator.next(); 
// step1: { value: 1, done: false }

// Resumes execution, injects 'true' into the 'condition' variable.
const step2 = iterator.next(true); 
// step2: { value: 2, done: false }

// Resumes execution, hits the return statement.
const step3 = iterator.next(false); 
// step3: { value: "Stream Complete", done: true }

class TreeTraversal {
    *leftBranch(): Generator<number, void, unknown> {
        yield 1;
        yield 2;
    }

    *traverse(): Generator<number, void, unknown> {
        yield 0;
        // Delegates execution to leftBranch() until it completes
        yield* this.leftBranch(); 
        yield 3;
    }
}

class AsyncDataFetcher {
    async *fetchChunks(): AsyncGenerator<Uint8Array, void, unknown> {
        const chunk1 = await Promise.resolve(new Uint8Array([1, 2]));
        yield chunk1;
        
        const chunk2 = await Promise.resolve(new Uint8Array([3, 4]));
        yield chunk2;
    }
}