style: 完成所有文件的lint

2026-06-18 22:35:51 +00:00 · 2026-05-01 21:39:30 +08:00
parent d136872cc9
commit 6182015005
1333 changed files with 68255 additions and 77882 deletions
--- a/src/utils/tests/stream.test.ts
+++ b/src/utils/tests/stream.test.ts
@@ -1,162 +1,164 @@
-import { describe, expect, test } from "bun:test";
-import { Stream } from "../stream";
+import { describe, expect, test } from 'bun:test'
+import { Stream } from '../stream'

-describe("Stream", () => {
-  test("enqueue then read resolves with the value", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    stream.enqueue(42);
-    const result = await stream.next();
-    expect(result).toEqual({ done: false, value: 42 });
-  });
+describe('Stream', () => {
+  test('enqueue then read resolves with the value', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    stream.enqueue(42)
+    const result = await stream.next()
+    expect(result).toEqual({ done: false, value: 42 })
+  })

-  test("enqueue multiple then drain in order", async () => {
-    const stream = new Stream<string>();
-    stream[Symbol.asyncIterator]();
-    stream.enqueue("a");
-    stream.enqueue("b");
-    stream.enqueue("c");
-    expect(await stream.next()).toEqual({ done: false, value: "a" });
-    expect(await stream.next()).toEqual({ done: false, value: "b" });
-    expect(await stream.next()).toEqual({ done: false, value: "c" });
-  });
+  test('enqueue multiple then drain in order', async () => {
+    const stream = new Stream<string>()
+    stream[Symbol.asyncIterator]()
+    stream.enqueue('a')
+    stream.enqueue('b')
+    stream.enqueue('c')
+    expect(await stream.next()).toEqual({ done: false, value: 'a' })
+    expect(await stream.next()).toEqual({ done: false, value: 'b' })
+    expect(await stream.next()).toEqual({ done: false, value: 'c' })
+  })

-  test("next() blocks until enqueue provides a value", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    const promise = stream.next();
+  test('next() blocks until enqueue provides a value', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    const promise = stream.next()
    // Not resolved yet — enqueue after a microtask
-    stream.enqueue(99);
-    const result = await promise;
-    expect(result).toEqual({ done: false, value: 99 });
-  });
+    stream.enqueue(99)
+    const result = await promise
+    expect(result).toEqual({ done: false, value: 99 })
+  })

-  test("done() resolves pending reader with done:true", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    const promise = stream.next();
-    stream.done();
-    expect(await promise).toEqual({ done: true, value: undefined });
-  });
+  test('done() resolves pending reader with done:true', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    const promise = stream.next()
+    stream.done()
+    expect(await promise).toEqual({ done: true, value: undefined })
+  })

-  test("done() with no pending reader — subsequent next returns done:true", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    stream.done();
-    expect(await stream.next()).toEqual({ done: true, value: undefined });
-  });
+  test('done() with no pending reader — subsequent next returns done:true', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    stream.done()
+    expect(await stream.next()).toEqual({ done: true, value: undefined })
+  })

-  test("error() rejects pending reader", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    const promise = stream.next();
-    stream.error(new Error("boom"));
-    expect(promise).rejects.toThrow("boom");
-  });
+  test('error() rejects pending reader', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    const promise = stream.next()
+    stream.error(new Error('boom'))
+    expect(promise).rejects.toThrow('boom')
+  })

-  test("error() after done — hasError is set but next returns done:true (isDone checked first)", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    stream.done();
-    stream.error(new Error("late error"));
+  test('error() after done — hasError is set but next returns done:true (isDone checked first)', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    stream.done()
+    stream.error(new Error('late error'))
    // next() checks isDone before hasError, so it returns done:true
-    expect(await stream.next()).toEqual({ done: true, value: undefined });
-  });
+    expect(await stream.next()).toEqual({ done: true, value: undefined })
+  })

-  test("enqueue after done — queue is checked before isDone, value is consumed", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    stream.done();
-    stream.enqueue(1);
+  test('enqueue after done — queue is checked before isDone, value is consumed', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    stream.done()
+    stream.enqueue(1)
    // next() checks queue.length > 0 first, so enqueued value is returned
-    expect(await stream.next()).toEqual({ done: false, value: 1 });
+    expect(await stream.next()).toEqual({ done: false, value: 1 })
    // After draining queue, done takes effect
-    expect(await stream.next()).toEqual({ done: true, value: undefined });
-  });
+    expect(await stream.next()).toEqual({ done: true, value: undefined })
+  })

-  test("return() marks stream as done and calls returned callback", async () => {
-    let called = false;
-    const stream = new Stream<number>(() => { called = true; });
-    stream[Symbol.asyncIterator]();
-    const result = await stream.return();
-    expect(result).toEqual({ done: true, value: undefined });
-    expect(called).toBe(true);
+  test('return() marks stream as done and calls returned callback', async () => {
+    let called = false
+    const stream = new Stream<number>(() => {
+      called = true
+    })
+    stream[Symbol.asyncIterator]()
+    const result = await stream.return()
+    expect(result).toEqual({ done: true, value: undefined })
+    expect(called).toBe(true)
    // Subsequent next returns done
-    expect(await stream.next()).toEqual({ done: true, value: undefined });
-  });
+    expect(await stream.next()).toEqual({ done: true, value: undefined })
+  })

-  test("return() without callback still works", async () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
-    const result = await stream.return();
-    expect(result).toEqual({ done: true, value: undefined });
-  });
+  test('return() without callback still works', async () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
+    const result = await stream.return()
+    expect(result).toEqual({ done: true, value: undefined })
+  })

-  test("Symbol.asyncIterator throws on second call", () => {
-    const stream = new Stream<number>();
-    stream[Symbol.asyncIterator]();
+  test('Symbol.asyncIterator throws on second call', () => {
+    const stream = new Stream<number>()
+    stream[Symbol.asyncIterator]()
    expect(() => stream[Symbol.asyncIterator]()).toThrow(
-      "Stream can only be iterated once"
-    );
-  });
+      'Stream can only be iterated once',
+    )
+  })

-  test("for-await-of iteration drains queued values then ends", async () => {
-    const stream = new Stream<string>();
-    stream.enqueue("x");
-    stream.enqueue("y");
-    stream.done();
-    const results: string[] = [];
+  test('for-await-of iteration drains queued values then ends', async () => {
+    const stream = new Stream<string>()
+    stream.enqueue('x')
+    stream.enqueue('y')
+    stream.done()
+    const results: string[] = []
    for await (const value of stream) {
-      results.push(value);
+      results.push(value)
    }
-    expect(results).toEqual(["x", "y"]);
-  });
+    expect(results).toEqual(['x', 'y'])
+  })

-  test("for-await-of blocks until done", async () => {
-    const stream = new Stream<number>();
-    const results: number[] = [];
+  test('for-await-of blocks until done', async () => {
+    const stream = new Stream<number>()
+    const results: number[] = []

    const iterPromise = (async () => {
      for await (const v of stream) {
-        results.push(v);
+        results.push(v)
      }
-    })();
+    })()

    // Enqueue after a tick
-    await Promise.resolve();
-    stream.enqueue(1);
-    stream.enqueue(2);
-    stream.done();
+    await Promise.resolve()
+    stream.enqueue(1)
+    stream.enqueue(2)
+    stream.done()

-    await iterPromise;
-    expect(results).toEqual([1, 2]);
-  });
+    await iterPromise
+    expect(results).toEqual([1, 2])
+  })

-  test("error during for-await-of rejects the loop", async () => {
-    const stream = new Stream<number>();
+  test('error during for-await-of rejects the loop', async () => {
+    const stream = new Stream<number>()
    const iterPromise = (async () => {
      for await (const _ of stream) {
        // will error before any value
      }
-    })();
-    stream.error(new Error("stream broken"));
-    expect(iterPromise).rejects.toThrow("stream broken");
-  });
+    })()
+    stream.error(new Error('stream broken'))
+    expect(iterPromise).rejects.toThrow('stream broken')
+  })

-  test("concurrent enqueue from multiple sources does not lose data", async () => {
-    const stream = new Stream<number>();
+  test('concurrent enqueue from multiple sources does not lose data', async () => {
+    const stream = new Stream<number>()
    // Rapid sequential enqueue
    for (let i = 0; i < 100; i++) {
-      stream.enqueue(i);
+      stream.enqueue(i)
    }
-    stream.done();
+    stream.done()

-    const results: number[] = [];
+    const results: number[] = []
    for await (const v of stream) {
-      results.push(v);
+      results.push(v)
    }
-    expect(results.length).toBe(100);
-    expect(results[0]).toBe(0);
-    expect(results[99]).toBe(99);
-  });
-});
+    expect(results.length).toBe(100)
+    expect(results[0]).toBe(0)
+    expect(results[99]).toBe(99)
+  })
+})