How to fix Generator function must return Generator type in TypeScript

// WRONG - using Iterable or Iterator
function* countToThree(): Iterable<number> {
  yield 1;
  yield 2;
  yield 3;
}

// CORRECT - using Generator
function* countToThree(): Generator<number> {
  yield 1;
  yield 2;
  yield 3;
}

// With all three type parameters
function* createCounter(): Generator<number, void, number> {
  let count = 0;
  while (true) {
    const reset = yield count++;
    if (reset === 0) {
      count = 0;
    }
  }
}

// Let TypeScript infer - usually works fine
function* generateIds() {
  let id = 0;
  while (true) {
    yield id++;
  }
}

// TypeScript infers: Generator<number, never, unknown>

// Only annotate when inference fails or for documentation
function* parseLines(text: string): Generator<string> {
  for (const line of text.split('
')) {
    yield line.trim();
  }
}

// WRONG - using Generator for async function
async function* fetchPages(): Generator<Promise<string>> {
  for (let i = 0; i < 5; i++) {
    const response = await fetch(`/api/page/${i}`);
    yield response.text();
  }
}

// CORRECT - using AsyncGenerator
async function* fetchPages(): AsyncGenerator<string> {
  for (let i = 0; i < 5; i++) {
    const response = await fetch(`/api/page/${i}`);
    yield response.text();
  }
}

// With explicit return type
async function* timer(seconds: number): AsyncGenerator<string, void, unknown> {
  for (let i = 0; i < seconds; i++) {
    await new Promise(resolve => setTimeout(resolve, 1000));
    yield `Tick ${i + 1}`;
  }
}

// WRONG - mixed yields without proper union type
function* mixedGenerator(flag: boolean) {
  if (flag) {
    yield "string";
  } else {
    yield 42;
  }
  return true;
}

// CORRECT - explicit union type for yields
function* mixedGenerator(flag: boolean): Generator<string | number, boolean> {
  if (flag) {
    yield "string";
  } else {
    yield 42;
  }
  return true;
}

// Complex example with different next() input types
function* interactive(): Generator<string, void, string | number> {
  let input: string | number;
  while ((input = yield "Enter something:") !== "quit") {
    console.log(`You entered: ${input}`);
  }
}

function* infiniteNumbers(): Generator<number, never> {
  let n = 0;
  while (true) {
    yield n++;
  }
}

{
  "compilerOptions": {
    "target": "es2015",  // or higher for generator support
    "lib": ["es2015", "dom"],  // includes generator types
    "downlevelIteration": true  // if targeting ES5
  }
}

npx tsc --version

// Type for a generator that yields T and returns R
type SimpleGenerator<T, R = void> = Generator<T, R>;

// Type for an infinite generator
type InfiniteGenerator<T> = Generator<T, never>;

// Factory function with proper typing
function createCounter(start = 0): Generator<number> {
  return (function* () {
    let n = start;
    while (true) {
      yield n++;
    }
  })();
}

// Generic generator wrapper
function* mapGenerator<T, U>(
  generator: Generator<T>,
  mapper: (value: T) => U
): Generator<U> {
  for (const value of generator) {
    yield mapper(value);
  }
}

// Usage
const numbers = createCounter();
const doubled = mapGenerator(numbers, n => n * 2);