refactor(scraper): minor code cleanup as suggested in code review

- replace () => {return {...};} with () => ({...})
- remove commented-out code
- move utils to their own files in /app/utils
  - create '#utils/' subpath imports for /app/utils

Author: mini-bomba

backend/app/utils/arrays.ts

@@ -0,0 +1,20 @@
+export function chunkArray<T>(array: T[], chunkSize: number): T[][] {
+  const result = [];
+  const input = Array.from(array);
+  while (input.length > 0) {
+    result.push(input.splice(0, chunkSize));
+  }
+  return result;
+}
+
+export function zip<T1, T2>(a1: T1[], a2: T2[]): [T1, T2][] {
+  const array1 = Array.from(a1);
+  const array2 = Array.from(a2);
+  const result: [T1, T2][] = [];
+  while (array1.length > 0 && array2.length > 0) {
+    const el1 = array1.shift() as T1;
+    const el2 = array2.shift() as T2;
+    result.push([el1, el2]);
+  }
+  return result;
+}

backend/app/utils/semaphore.ts

@@ -0,0 +1,49 @@
+export class Semaphore {
+  capacity: number;
+  #currentTasks: number;
+  #waitingTasks: (() => void)[];
+
+  constructor(capacity: number) {
+    this.capacity = capacity;
+    this.#currentTasks = 0;
+    this.#waitingTasks = [];
+  }
+
+  public get currentTasks(): number {
+    return this.#currentTasks;
+  }
+
+  public async runTask<T>(task: () => Promise<T>): Promise<T> {
+    // acquire the semaphore
+    await this.acquire();
+    try {
+      // execute the task
+      return await task();
+    } finally {
+      // don't forget to release
+      this.release();
+    }
+  }
+
+  private acquire(): Promise<void> {
+    // if we're under capacity, bump the count and resolve immediately
+    if (this.capacity > this.#currentTasks) {
+      this.#currentTasks += 1;
+      return Promise.resolve();
+    }
+    // otherwise add ourselves to the queue
+    return new Promise((resolve) => this.#waitingTasks.push(resolve));
+  }
+
+  private release() {
+    // try waking up the next task
+    const nextTask = this.#waitingTasks.shift();
+    if (nextTask === undefined) {
+      // no task in queue, decrement task count
+      this.#currentTasks -= 1;
+    } else {
+      // wake up the task
+      nextTask();
+    }
+  }
+}