JavaScript Generators & Iterators — Lazy Sequences, Async Iteration, and Custom Iterables

const arr = [10, 20, 30];
const iterator = arr[Symbol.iterator]();

console.log(iterator.next()); // { value: 10, done: false }
console.log(iterator.next()); // { value: 20, done: false }
console.log(iterator.next()); // { value: 30, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

// for...of uses this protocol internally:
for (const val of arr) {
  console.log(val);
}

// Range: iterate over a range of numbers
class Range {
  constructor(start, end, step = 1) {
    this.start = start;
    this.end = end;
    this.step = step;
  }

  [Symbol.iterator]() {
    let current = this.start;
    const end = this.end;
    const step = this.step;

    return {
      next() {
        if (current <= end) {
          const value = current;
          current += step;
          return { value, done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}

const nums = new Range(1, 5);
console.log([...nums]); // [1, 2, 3, 4, 5]

// Paginated API client (iterable)
class ApiPaginator {
  constructor(baseUrl, pageSize = 50) {
    this.baseUrl = baseUrl;
    this.pageSize = pageSize;
  }

  [Symbol.iterator]() {
    let page = 1;
    let hasMore = true;
    const baseUrl = this.baseUrl;
    const pageSize = this.pageSize;

    return {
      async next() {
        if (!hasMore) return { done: true };

        const response = await fetch(
          `${baseUrl}?page=${page}&limit=${pageSize}`
        );
        const data = await response.json();
        hasMore = data.hasMore;
        page++;
        return { value: data.items, done: false };
      }
    };
  }
}

function* countUpTo(max) {
  for (let i = 1; i <= max; i++) {
    yield i;
  }
}

const generator = countUpTo(3);
console.log([...generator]); // [1, 2, 3]

function* infiniteFibonacci() {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

const fib = infiniteFibonacci();
console.log(fib.next().value); // 0
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
// Take first 10 fibonacci numbers
const first10 = [...new Array(10)].map(() => fib.next().value);

function* questionMachine() {
  const answer = yield "What is your name?";
  yield `Hello, ${answer}!`;
  const age = yield "How old are you?";
  yield `You are ${age} years old.`;
}

const qm = questionMachine();
console.log(qm.next().value);       // "What is your name?"
console.log(qm.next("Alice").value); // "Hello, Alice!"
console.log(qm.next().value);       // "How old are you?"
console.log(qm.next(30).value);     // "You are 30 years old."

function* letters() {
  yield "a";
  yield "b";
  yield "c";
}

function* combined() {
  yield 1;
  yield* letters();  // Delegates to letters()
  yield 2;
}

console.log([...combined()]); // [1, "a", "b", "c", 2]

// Practical: flatten nested arrays
function* flatten(arr) {
  for (const item of arr) {
    if (Array.isArray(item)) {
      yield* flatten(item);
    } else {
      yield item;
    }
  }
}

// Async generator: yields Promises
async function* fetchPages(url, maxPages = 5) {
  for (let page = 1; page <= maxPages; page++) {
    const response = await fetch(`${url}?page=${page}`);
    const data = await response.json();
    yield data;
    if (!data.hasMore) break;
  }
}

// Consume with for-await-of
async function getAllItems() {
  const allItems = [];
  for await (const page of fetchPages("/api/items")) {
    allItems.push(...page.items);
  }
  return allItems;
}

// Async iterator protocol
class AsyncRange {
  constructor(start, end, delay = 100) {
    this.start = start;
    this.end = end;
    this.delay = delay;
  }

  [Symbol.asyncIterator]() {
    let current = this.start;
    const end = this.end;
    const delay = this.delay;

    return {
      async next() {
        await new Promise(r => setTimeout(r, delay));
        if (current <= end) {
          return { value: current++, done: false };
        }
        return { value: undefined, done: true };
      }
    };
  }
}

(async () => {
  for await (const num of new AsyncRange(1, 3, 50)) {
    console.log(num); // 1, 2, 3 (with 50ms delay each)
  }
})();

function* middlewarePipeline(middlewares, initialCtx) {
  let ctx = initialCtx;
  for (const mw of middlewares) {
    ctx = yield mw(ctx);
  }
  return ctx;
}

// Usage: DodaTech's scan pipeline
const pipeline = middlewarePipeline([
  (ctx) => ({ ...ctx, validated: true }),
  (ctx) => ({ ...ctx, scanned: true }),
  (ctx) => ({ ...ctx, reported: true }),
], { url: "https://example.com" });

function* map(iterable, fn) {
  for (const item of iterable) {
    yield fn(item);
  }
}

function* filter(iterable, predicate) {
  for (const item of iterable) {
    if (predicate(item)) {
      yield item;
    }
  }
}

function* take(iterable, n) {
  let count = 0;
  for (const item of iterable) {
    if (count >= n) break;
    yield item;
    count++;
  }
}

// Lazy pipeline — no intermediate arrays!
const numbers = new Range(1, 1000000);
const result = [
  ...take(
    filter(
      map(numbers, n => n * 2),
      n => n % 3 === 0
    ),
    5
  )
];
console.log(result); // [6, 12, 18, 24, 30]

function* rateLimiter(maxPerSecond) {
  const timestamps = [];
  while (true) {
    const now = Date.now();
    const windowStart = now - 1000;
    // Remove old timestamps
    while (timestamps.length && timestamps[0] < windowStart) {
      timestamps.shift();
    }
    if (timestamps.length < maxPerSecond) {
      timestamps.push(now);
      yield true;
    } else {
      yield false;
    }
  }
}