refactor: complete JS to TypeScript migration

- Convert all 5 JS source files to TypeScript
- Add generic type parameter to intersect<T>() function
- Optimize Set creation: move outside filter callback (was creating new Set per element)
- Extract CHUNK_SIZE, TOTAL_LINES, MAX_VALUE constants
- Fix inverted error callback logic in writeResult
- Fix parseInt(Math.random()) → Math.floor(Math.random())
- Type stream processing with fs.WriteStream
- Replace require() with ES module imports
- Replace module.exports with export default
- Translate Chinese comments to English

Author: refactor-bot

index.js

@@ -0,0 +1,12 @@
+/**
+ * Intersect - Main entry point.
+ * Reads the 3M dataset, then processes the 60M dataset to find intersections.
+ */
+import readSmallData from './library/data-3M';
+import processLargeData from './library/data-60M';
+
+(async (): Promise<void> => {
+  const smallData = await readSmallData();
+  const result = await processLargeData(smallData);
+  console.log(result);
+})();

index.ts

@@ -0,0 +1,38 @@
+/**
+ * Generate a 60M random number dataset and write to a text file.
+ * Uses stream backpressure handling for efficient writing.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+const OUTPUT_PATH = path.resolve(__dirname, '../database/data-60M.txt');
+const TOTAL_LINES = 600000;
+const MAX_VALUE = 60000000;
+
+const writer = fs.createWriteStream(OUTPUT_PATH, { highWaterMark: 1 });
+
+/** Write random numbers to the output file using stream backpressure. */
+function writeSixtyMillionTimes(writer: fs.WriteStream): void {
+  let remaining = TOTAL_LINES;
+
+  const write = (): void => {
+    let ok = true;
+    do {
+      remaining--;
+      const data = Buffer.from(`${Math.floor(Math.random() * MAX_VALUE)}\n`);
+      if (remaining === 0) {
+        writer.write(data);
+      } else {
+        ok = writer.write(data);
+      }
+    } while (remaining > 0 && ok);
+
+    if (remaining > 0) {
+      writer.once('drain', write);
+    }
+  };
+
+  write();
+}
+
+writeSixtyMillionTimes(writer);

library/create-60M.js

@@ -0,0 +1,22 @@
+/**
+ * Read the 3M dataset line by line from a text file.
+ * @returns Array of strings, one per line.
+ */
+import * as fs from 'fs';
+import * as readline from 'readline';
+
+export default function readSmallData(): Promise<string[]> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: fs.createReadStream('./database/data-3M.txt'),
+      crlfDelay: Infinity,
+    });
+    const lines: string[] = [];
+    rl.on('line', (line: string) => {
+      lines.push(line);
+    });
+    rl.on('close', () => {
+      resolve(lines);
+    });
+  });
+}

library/create-60M.ts

@@ -0,0 +1,64 @@
+/**
+ * Process the 60M dataset in chunks, computing intersections with the small dataset.
+ * Reads the large file as a stream, processing 600 lines at a time.
+ */
+import { createReadStream, appendFile } from 'fs';
+import * as readline from 'readline';
+import intersect from './intersect';
+
+/** Append an intersection result to the output file. */
+function writeResult(element: string): void {
+  appendFile('./result.txt', `${element}\n`, (err) => {
+    if (err) {
+      console.log('Write failed');
+    }
+  });
+}
+
+/** Chunk size: number of lines to process per batch. */
+const CHUNK_SIZE = 600;
+
+/**
+ * Stream-process the 60M dataset, finding intersections with smallData.
+ * @param smallData - The smaller dataset to intersect against.
+ * @returns Promise that resolves when processing is complete.
+ */
+export default function processLargeData(smallData: string[]): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: createReadStream('./database/data-60M.txt', {
+        highWaterMark: 50,
+      }),
+      crlfDelay: Infinity,
+    });
+
+    let lineCount = 0;
+    let rawData: string[] = [];
+
+    rl.on('line', (line: string) => {
+      rawData.push(line);
+      console.log(line, rawData.length);
+      lineCount++;
+
+      if (lineCount === CHUNK_SIZE) {
+        console.log('Read count:', lineCount);
+        console.log('Extracted data:', rawData);
+
+        rl.pause();
+
+        const intersectResult = intersect(rawData, smallData);
+        intersectResult.forEach((element) => writeResult(element));
+
+        setTimeout(() => {
+          rawData = [];
+          lineCount = 0;
+          rl.resume();
+        }, 0);
+      }
+    });
+
+    rl.on('close', () => {
+      resolve('Done');
+    });
+  });
+}

library/data-3M.js

@@ -0,0 +1,7 @@
+/**
+ * Compute the intersection of two arrays using a Set for O(n+m) performance.
+ */
+export default function intersect<T>(a: T[], b: T[]): T[] {
+  const setB = new Set(b);
+  return a.filter((x) => setB.has(x));
+}