style: 完成所有文件的lint

src/utils/__tests__/bufferedWriter.test.ts

@@ -1,117 +1,117 @@
-import { describe, expect, test } from "bun:test";
-import { createBufferedWriter } from "../bufferedWriter";
+import { describe, expect, test } from 'bun:test'
+import { createBufferedWriter } from '../bufferedWriter'
 
-describe("createBufferedWriter", () => {
-  test("immediateMode calls writeFn directly", () => {
-    const written: string[] = [];
+describe('createBufferedWriter', () => {
+  test('immediateMode calls writeFn directly', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
+      writeFn: c => written.push(c),
       immediateMode: true,
-    });
-    writer.write("a");
-    writer.write("b");
-    expect(written).toEqual(["a", "b"]);
-  });
+    })
+    writer.write('a')
+    writer.write('b')
+    expect(written).toEqual(['a', 'b'])
+  })
 
-  test("buffered mode accumulates until flush", () => {
-    const written: string[] = [];
+  test('buffered mode accumulates until flush', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
-    });
-    writer.write("hello ");
-    writer.write("world");
-    expect(written).toEqual([]);
-    writer.flush();
-    expect(written).toEqual(["hello world"]);
-  });
+      writeFn: c => written.push(c),
+    })
+    writer.write('hello ')
+    writer.write('world')
+    expect(written).toEqual([])
+    writer.flush()
+    expect(written).toEqual(['hello world'])
+  })
 
-  test("flush with empty buffer does not call writeFn", () => {
-    const written: string[] = [];
+  test('flush with empty buffer does not call writeFn', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
-    });
-    writer.flush();
-    expect(written).toEqual([]);
-  });
+      writeFn: c => written.push(c),
+    })
+    writer.flush()
+    expect(written).toEqual([])
+  })
 
-  test("flush clears the buffer", () => {
-    const written: string[] = [];
+  test('flush clears the buffer', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
-    });
-    writer.write("data");
-    writer.flush();
-    writer.flush(); // second flush should be no-op
-    expect(written).toEqual(["data"]);
-  });
+      writeFn: c => written.push(c),
+    })
+    writer.write('data')
+    writer.flush()
+    writer.flush() // second flush should be no-op
+    expect(written).toEqual(['data'])
+  })
 
-  test("overflow triggers deferred flush when maxBufferSize reached", () => {
-    const written: string[] = [];
+  test('overflow triggers deferred flush when maxBufferSize reached', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
+      writeFn: c => written.push(c),
       maxBufferSize: 2,
-    });
-    writer.write("a");
-    writer.write("b");
+    })
+    writer.write('a')
+    writer.write('b')
     // 2 writes = maxBufferSize, triggers flushDeferred via setImmediate
-    expect(written).toEqual([]);
-  });
+    expect(written).toEqual([])
+  })
 
-  test("overflow triggers deferred flush when maxBufferBytes reached", () => {
-    const written: string[] = [];
+  test('overflow triggers deferred flush when maxBufferBytes reached', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
+      writeFn: c => written.push(c),
       maxBufferBytes: 5,
-    });
-    writer.write("abc");
-    writer.write("def");
+    })
+    writer.write('abc')
+    writer.write('def')
     // total 6 bytes > 5, triggers flushDeferred
-    expect(written).toEqual([]);
-  });
+    expect(written).toEqual([])
+  })
 
-  test("dispose flushes remaining buffer", () => {
-    const written: string[] = [];
+  test('dispose flushes remaining buffer', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
-    });
-    writer.write("final");
-    writer.dispose();
-    expect(written).toEqual(["final"]);
-  });
+      writeFn: c => written.push(c),
+    })
+    writer.write('final')
+    writer.dispose()
+    expect(written).toEqual(['final'])
+  })
 
-  test("dispose flushes pending overflow", () => {
-    const written: string[] = [];
+  test('dispose flushes pending overflow', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
+      writeFn: c => written.push(c),
       maxBufferSize: 1,
-    });
-    writer.write("overflow-data");
+    })
+    writer.write('overflow-data')
     // overflow triggered but deferred; dispose should flush it synchronously
-    writer.dispose();
-    expect(written).toEqual(["overflow-data"]);
-  });
+    writer.dispose()
+    expect(written).toEqual(['overflow-data'])
+  })
 
-  test("coalesced overflow — multiple overflows merge before write", () => {
-    const written: string[] = [];
+  test('coalesced overflow — multiple overflows merge before write', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
+      writeFn: c => written.push(c),
       maxBufferSize: 1,
-    });
-    writer.write("a"); // triggers first overflow (deferred)
-    writer.write("b"); // pendingOverflow exists, coalesces
-    writer.dispose();   // flushes coalesced overflow
-    expect(written).toEqual(["ab"]);
-  });
+    })
+    writer.write('a') // triggers first overflow (deferred)
+    writer.write('b') // pendingOverflow exists, coalesces
+    writer.dispose() // flushes coalesced overflow
+    expect(written).toEqual(['ab'])
+  })
 
-  test("multiple flushes produce concatenated writes", () => {
-    const written: string[] = [];
+  test('multiple flushes produce concatenated writes', () => {
+    const written: string[] = []
     const writer = createBufferedWriter({
-      writeFn: (c) => written.push(c),
-    });
-    writer.write("batch1");
-    writer.flush();
-    writer.write("batch2");
-    writer.flush();
-    expect(written).toEqual(["batch1", "batch2"]);
-  });
-});
+      writeFn: c => written.push(c),
+    })
+    writer.write('batch1')
+    writer.flush()
+    writer.write('batch2')
+    writer.flush()
+    expect(written).toEqual(['batch1', 'batch2'])
+  })
+})