feat: rename peak() to peek() and deprecate peak()

Rename `peak()` to `peek()` in IReaderBase with backward compatibility

Author: streamich

src/buffers/Reader.ts

@@ -12,10 +12,20 @@ export class Reader implements IReader, IReaderResettable {
     this.view = new DataView(uint8.buffer, uint8.byteOffset, uint8.length);
   }
 
-  public peak(): number {
+  /**
+   * Get current byte value without advancing the cursor.
+   */
+  public peek(): number {
     return this.view.getUint8(this.x);
   }
 
+  /**
+   * @deprecated Use peek() instead.
+   */
+  public peak(): number {
+    return this.peek();
+  }
+
   public skip(length: number): void {
     this.x += length;
   }

src/buffers/StreamingOctetReader.ts

@@ -129,11 +129,19 @@ export class StreamingOctetReader {
     this.skipUnsafe(n);
   }
 
-  public peak(): number {
+  public peek(): number {
     this.assertSize(1);
     return this.chunks[0]![this.x];
   }
 
+  /**
+   * Get current byte value without advancing the cursor.
+   * @deprecated Use peek() instead.
+   */
+  public peak(): number {
+    return this.peek();
+  }
+
   public utf8(length: number, mask: [number, number, number, number], maskIndex: number): string {
     this.assertSize(length);
     let i = 0;

src/buffers/StreamingReader.ts

@@ -68,11 +68,19 @@ export class StreamingReader implements IReader, IReaderResettable {
     this.dx = x - this.writer.x0;
   }
 
-  public peak(): number {
+  public peek(): number {
     this.assertSize(1);
     return this.view.getUint8(this.x);
   }
 
+  /**
+   * Get current byte value without advancing the cursor.
+   * @deprecated Use peek() instead.
+   */
+  public peak(): number {
+    return this.peek();
+  }
+
   public skip(length: number): void {
     this.assertSize(length);
     this.x += length;

src/buffers/__tests__/peak-peek.spec.ts

@@ -0,0 +1,119 @@
+import {Reader} from '../Reader';
+import {StreamingReader} from '../StreamingReader';
+import {StreamingOctetReader} from '../StreamingOctetReader';
+
+describe('peak() and peek() methods', () => {
+  describe('Reader', () => {
+    test('peak() returns current byte without advancing cursor', () => {
+      const reader = new Reader();
+      reader.reset(new Uint8Array([1, 2, 3, 4, 5]));
+      expect(reader.x).toBe(0);
+      expect(reader.peak()).toBe(1);
+      expect(reader.x).toBe(0); // cursor should not advance
+
+      reader.u8(); // advance cursor
+      expect(reader.x).toBe(1);
+      expect(reader.peak()).toBe(2);
+      expect(reader.x).toBe(1); // cursor should not advance
+    });
+
+    test('peek() returns current byte without advancing cursor', () => {
+      const reader = new Reader();
+      reader.reset(new Uint8Array([1, 2, 3, 4, 5]));
+
+      expect(reader.x).toBe(0);
+      expect(reader.peek()).toBe(1);
+      expect(reader.x).toBe(0); // cursor should not advance
+
+      reader.u8(); // advance cursor
+      expect(reader.x).toBe(1);
+      expect(reader.peek()).toBe(2);
+      expect(reader.x).toBe(1); // cursor should not advance
+    });
+
+    test('peak() and peek() return the same value', () => {
+      const reader = new Reader();
+      reader.reset(new Uint8Array([42, 100, 255]));
+
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+    });
+  });
+
+  describe('StreamingReader', () => {
+    test('peak() returns current byte without advancing cursor', () => {
+      const reader = new StreamingReader();
+      reader.push(new Uint8Array([10, 20, 30]));
+
+      expect(reader.x).toBe(0);
+      expect(reader.peak()).toBe(10);
+      expect(reader.x).toBe(0); // cursor should not advance
+
+      reader.u8(); // advance cursor
+      expect(reader.x).toBe(1);
+      expect(reader.peak()).toBe(20);
+      expect(reader.x).toBe(1); // cursor should not advance
+    });
+
+    test('peek() returns current byte without advancing cursor', () => {
+      const reader = new StreamingReader();
+      reader.push(new Uint8Array([10, 20, 30]));
+
+      expect(reader.x).toBe(0);
+      expect(reader.peek()).toBe(10);
+      expect(reader.x).toBe(0); // cursor should not advance
+
+      reader.u8(); // advance cursor
+      expect(reader.x).toBe(1);
+      expect(reader.peek()).toBe(20);
+      expect(reader.x).toBe(1); // cursor should not advance
+    });
+
+    test('peak() and peek() return the same value', () => {
+      const reader = new StreamingReader();
+      reader.push(new Uint8Array([42, 100, 255]));
+
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+    });
+  });
+
+  describe('StreamingOctetReader', () => {
+    test('peak() returns current byte without advancing cursor', () => {
+      const reader = new StreamingOctetReader();
+      reader.push(new Uint8Array([100, 200, 150]));
+
+      expect(reader.peak()).toBe(100);
+
+      reader.u8(); // advance cursor internally
+      expect(reader.peak()).toBe(200);
+    });
+
+    test('peek() returns current byte without advancing cursor', () => {
+      const reader = new StreamingOctetReader();
+      reader.push(new Uint8Array([100, 200, 150]));
+
+      expect(reader.peek()).toBe(100);
+
+      reader.u8(); // advance cursor internally
+      expect(reader.peek()).toBe(200);
+    });
+
+    test('peak() and peek() return the same value', () => {
+      const reader = new StreamingOctetReader();
+      reader.push(new Uint8Array([42, 100, 255]));
+
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+      reader.u8(); // advance cursor
+      expect(reader.peak()).toBe(reader.peek());
+    });
+  });
+});

src/buffers/types.ts

@@ -71,6 +71,12 @@ export interface IWriterGrowable {
 
 export interface IReaderBase {
   /** Get current byte value without advancing the cursor. */
+  peek(): number;
+
+  /**
+   * Get current byte value without advancing the cursor.
+   * @deprecated Use peek() instead.
+   */
   peak(): number;
 
   /** Advance the cursor given number of octets. */