refactor: fix lint

Author: John Doe

packages/utils/src/lib/performance-observer.ts

@@ -5,12 +5,14 @@ import {
 } from 'node:perf_hooks';
 import type { Buffered, Encoder, Sink } from './sink-source.types.js';
 
-export interface PerformanceObserverOptions<T> {
+export const DEFAULT_FLUSH_THRESHOLD = 20;
+
+export type PerformanceObserverOptions<T> = {
   sink: Sink<T, unknown>;
   encode: (entry: PerformanceEntry) => T[];
   captureBuffered?: boolean;
   flushThreshold?: number;
-}
+};
 
 export class PerformanceObserverHandle<T>
   implements Buffered, Encoder<PerformanceEntry, T[]>
@@ -28,7 +30,7 @@ export class PerformanceObserverHandle<T>
     this.#encode = options.encode;
     this.#sink = options.sink;
     this.#captureBuffered = options.captureBuffered ?? false;
-    this.#flushThreshold = options.flushThreshold ?? 20;
+    this.#flushThreshold = options.flushThreshold ?? DEFAULT_FLUSH_THRESHOLD;
     this.#observedEntryCount = 0;
   }
 
@@ -37,7 +39,9 @@ export class PerformanceObserverHandle<T>
   }
 
   connect(): void {
-    if (this.#observer || this.#closed) return;
+    if (this.#observer || this.#closed) {
+      return;
+    }
     this.#observer = new PerformanceObserver(() => {
       this.#observedEntryCount++;
       if (this.#observedEntryCount >= this.#flushThreshold) {
@@ -53,42 +57,50 @@ export class PerformanceObserverHandle<T>
   }
 
   flush(clear = false): void {
-    if (this.#closed || !this.#sink) return;
+    if (this.#closed || !this.#sink) {
+      return;
+    }
     const entries = [
       ...performance.getEntriesByType('mark'),
       ...performance.getEntriesByType('measure'),
     ];
 
     // Process all entries
-    for (const e of entries) {
-      if (e.entryType !== 'mark' && e.entryType !== 'measure') continue;
-
-      // Skip if already processed (unless clearing)
-      if (!clear && this.#processedEntries.has(e.name)) continue;
+    entries
+      .filter(e => e.entryType === 'mark' || e.entryType === 'measure')
+      .filter(e => clear || !this.#processedEntries.has(e.name))
+      .forEach(e => {
+        const encoded = this.encode(e);
+        encoded.forEach(item => {
+          this.#sink.write(item);
+        });
 
-      const encoded = this.encode(e);
-      for (const item of encoded) {
-        this.#sink.write(item);
-      }
-
-      if (clear) {
-        this.#processedEntries.delete(e.name);
-        if (e.entryType === 'mark') performance.clearMarks(e.name);
-        if (e.entryType === 'measure') performance.clearMeasures(e.name);
-      } else {
-        this.#processedEntries.add(e.name);
-      }
-    }
+        if (clear) {
+          this.#processedEntries.delete(e.name);
+          if (e.entryType === 'mark') {
+            performance.clearMarks(e.name);
+          }
+          if (e.entryType === 'measure') {
+            performance.clearMeasures(e.name);
+          }
+        } else {
+          this.#processedEntries.add(e.name);
+        }
+      });
   }
 
   disconnect(): void {
-    if (!this.#observer) return;
+    if (!this.#observer) {
+      return;
+    }
     this.#observer?.disconnect();
     this.#observer = undefined;
   }
 
   close(): void {
-    if (this.#closed) return;
+    if (this.#closed) {
+      return;
+    }
     this.flush();
     this.#closed = true;
     this.disconnect();

packages/utils/src/lib/performance-observer.unit.test.ts

@@ -26,15 +26,15 @@ vi.mock('node:perf_hooks', () => ({
 
 class MockSink<T> implements Sink<T, unknown> {
   open(): void {
-    throw new Error('Method not implemented.');
+    throw new Error(`Method not implemented in ${this.constructor.name}.`);
   }
 
   close(): void {
-    throw new Error('Method not implemented.');
+    throw new Error(`Method not implemented in ${this.constructor.name}.`);
   }
 
-  encode(input: T): unknown {
-    throw new Error('Method not implemented.');
+  encode(_input: T): unknown {
+    throw new Error(`Method not implemented in ${this.constructor.name}.`);
   }
 
   written: T[] = [];
@@ -59,8 +59,7 @@ const mockMeasureEntry = {
 } as PerformanceEntry;
 
 describe('PerformanceObserverHandle', () => {
-  let getEntriesByTypeSpy = vi.spyOn(performance, 'getEntriesByType');
-  let observedTrigger: (() => void) | undefined;
+  const getEntriesByTypeSpy = vi.spyOn(performance, 'getEntriesByType');
   let mockObserverInstance: {
     observe: MockedFunction<any>;
     disconnect: MockedFunction<any>;

packages/utils/src/lib/sink-source.types.ts

@@ -1,41 +1,41 @@
-export interface Encoder<I, O> {
-  encode(input: I): O;
-}
-
-export interface Decoder<O, I> {
-  decode(output: O): I;
-}
-
-export interface Sink<I, O> extends Encoder<I, O> {
-  open(): void;
-  write(input: I): void;
-  close(): void;
-}
-
-export interface Buffered {
-  flush(): void;
-}
-export interface BufferedSink<I, O> extends Sink<I, O>, Buffered {}
-
-export interface Source<I, O = any> {
-  read?(): O;
-  decode?(input: I): O;
-}
-
-export interface Recoverable {
-  recover(): RecoverResult;
-  repack(): void;
-  finalize(): void;
-}
-
-export interface RecoverResult<T = any> {
+export type Encoder<I, O> = {
+  encode: (input: I) => O;
+};
+
+export type Decoder<O, I> = {
+  decode: (output: O) => I;
+};
+
+export type Sink<I, O> = {
+  open: () => void;
+  write: (input: I) => void;
+  close: () => void;
+} & Encoder<I, O>;
+
+export type Buffered = {
+  flush: () => void;
+};
+export type BufferedSink<I, O> = {} & Sink<I, O> & Buffered;
+
+export type Source<I, O = unknown> = {
+  read?: () => O;
+  decode?: (input: I) => O;
+};
+
+export type Recoverable = {
+  recover: () => RecoverResult;
+  repack: () => void;
+  finalize: () => void;
+};
+
+export type RecoverResult<T = unknown> = {
   records: T[];
-  errors: Array<{ lineNo: number; line: string; error: Error }>;
+  errors: { lineNo: number; line: string; error: Error }[];
   partialTail: string | null;
-}
+};
 
-export interface RecoverOptions<T = any> {
+export type RecoverOptions = {
   keepInvalid?: boolean;
-}
+};
 
-export interface Output<I, O> extends BufferedSink<I, O> {}
+export type Output<I, O> = {} & BufferedSink<I, O>;