feat: add lastIndexOf method.

- Add lastIndexOf method to gets the last position at which the given value
can be found in the buffer.
- Add test cases for lastIndexOf method.
- Add indexOfWithDir method to reuse code of indexOf and lastIndexOf.

Author: ghosind

src/dynamicBuffer.ts

@@ -244,10 +244,10 @@ export class DynamicBuffer {
    * not present.
    *
    * ```js
-   * buf.append('Hello world');
-   * console.log(buf.indexOf('world'));
-   * // 6
-   * console.log(buf.indexOf('not in buffer'));
+   * buf.append('ABCABCABC');
+   * console.log(buf.indexOf('ABC'));
+   * // 0
+   * console.log(buf.indexOf('abc'));
    * // -1
    * ```
    *
@@ -262,24 +262,35 @@ export class DynamicBuffer {
     value: string | Buffer | Uint8Array | number | DynamicBuffer,
     byteOffset: number = 0,
     encoding: BufferEncoding = 'utf8',
-  ) {
-    let search: string | Buffer | Uint8Array | number;
-    if (value instanceof DynamicBuffer) {
-      search = value.buffer?.subarray(0, value.length) || '';
-    } else {
-      search = value;
-    }
-
-    if (!this.buffer || this.length === 0) {
-      return (typeof search === 'object' || typeof search === 'string') && search.length === 0 ? 0 : -1;
-    }
-
-    let start = byteOffset >= 0 ? byteOffset : this.length + byteOffset;
-    if (start >= this.length) {
-      start = this.length;
-    }
+  ): number {
+    return this.indexOfWithDir(true, value, byteOffset, encoding);
+  }
 
-    return this.buffer.subarray(0, this.length).indexOf(search, start, encoding);
+  /**
+   * Gets the last index at which the given value can be found in the buffer, or `-1` if it is
+   * not present.
+   *
+   * ```js
+   * buf.append('ABCABCABC');
+   * console.log(buf.indexOf('ABC'));
+   * // 6
+   * console.log(buf.indexOf('abc'));
+   * // -1
+   * ```
+   *
+   * @param value The value what to search for.
+   * @param byteOffset Where to begin searching in the buffer, and it'll be calculated from the
+   * end of buffer if it's negative. Default `this.length`.
+   * @param encoding The character encoding if the value is a string, default 'utf8'.
+   * @returns The index of last occurrence of value in the buffer, and `-1` if the buffer does
+   * not contain this value.
+   */
+  lastIndexOf(
+    value: string | Buffer | Uint8Array | number | DynamicBuffer,
+    byteOffset: number = this.length,
+    encoding: BufferEncoding = 'utf8',
+  ): number {
+    return this.indexOfWithDir(false, value, byteOffset, encoding);
   }
 
   /**
@@ -644,6 +655,48 @@ export class DynamicBuffer {
     this.size = newSize;
   }
 
+  /**
+   * Gets the first or last index at which the given value can be found in the buffer, or `-1`
+   * if it is not present.
+   *
+   * @param isFirst A boolean value to indicate the expected index is the first or last occurrence.
+   * @param value The value what to search for.
+   * @param byteOffset here to begin searching in the buffer.
+   * @param encoding The character encoding if the value is a string
+   * @returns The index of first or last occurrence of value in the buffer, and `-1` if the buffer
+   * does not contain this value.
+   */
+  private indexOfWithDir(
+    isFirst: boolean,
+    value: string | Buffer | Uint8Array | number | DynamicBuffer,
+    byteOffset: number,
+    encoding: BufferEncoding,
+  ): number {
+    let search: string | Buffer | Uint8Array | number;
+    if (value instanceof DynamicBuffer) {
+      search = value.buffer?.subarray(0, value.length) || '';
+    } else {
+      search = value;
+    }
+
+    if (!this.buffer || this.length === 0) {
+      return (typeof search === 'object' || typeof search === 'string') && search.length === 0
+        ? 0
+        : -1;
+    }
+
+    let start = byteOffset >= 0 ? byteOffset : this.length + byteOffset;
+    if (start >= this.length) {
+      start = this.length;
+    }
+
+    if (isFirst) {
+      return this.buffer.subarray(0, this.length).indexOf(search, start, encoding);
+    }
+
+    return this.buffer.subarray(0, this.length).lastIndexOf(search, start, encoding);
+  }
+
   /**
    * Calculate start and end offsets by optional parameters.
    *

test/search.spec.ts

@@ -182,3 +182,93 @@ describe('Includes tests', () => {
     assert.equal(buf.includes('', 32), true);
   });
 });
+
+describe('LastIndexOf tests', () => {
+  it('Test lastIndexOf with empty buffer and empty value.', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.lastIndexOf('ABC'), -1);
+    assert.equal(buf.lastIndexOf(''), 0);
+    assert.equal(buf.lastIndexOf(0), -1);
+    assert.equal(buf.lastIndexOf(Buffer.alloc(0)), 0);
+    assert.equal(buf.lastIndexOf(new Uint8Array()), 0);
+    assert.equal(buf.lastIndexOf(new DynamicBuffer()), 0);
+  });
+
+  it('Test lastIndexOf with empty value.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf(''), 9);
+    assert.equal(buf.lastIndexOf(0), -1);
+    assert.equal(buf.lastIndexOf(Buffer.alloc(0)), 9);
+    assert.equal(buf.lastIndexOf(new Uint8Array()), 9);
+    assert.equal(buf.lastIndexOf(new DynamicBuffer()), 9);
+  });
+
+  it('Test lastIndexOf with string.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf('ABC'), 6);
+    assert.equal(buf.lastIndexOf('BCA'), 4);
+    assert.equal(buf.lastIndexOf('abc'), -1);
+  });
+
+  it('Test lastIndexOf with number.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf(65), 6); // A
+    assert.equal(buf.lastIndexOf(67), 8); // C
+    assert.equal(buf.lastIndexOf(97), -1); // a
+  });
+
+  it('Test lastIndexOf with Buffer.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf(Buffer.from('ABC')), 6);
+    assert.equal(buf.lastIndexOf(Buffer.from('BCA')), 4);
+    assert.equal(buf.lastIndexOf(Buffer.from('abc')), -1);
+  });
+
+  it('Test lastIndexOf with Uint8Array.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf(new Uint8Array([0x41, 0x42, 0x43])), 6);
+    assert.equal(buf.lastIndexOf(new Uint8Array([0x42, 0x43, 0x41])), 4);
+    assert.equal(buf.lastIndexOf(new Uint8Array([0x61, 0x62, 0x63])), -1);
+  });
+
+  it('Test lastIndexOf with DynamicBuffer.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    const buf1 = new DynamicBuffer();
+    buf1.append('ABC');
+    assert.equal(buf.lastIndexOf(buf1), 6);
+
+    const buf2 = new DynamicBuffer();
+    buf2.append('BCA');
+    assert.equal(buf.lastIndexOf(buf2), 4);
+
+    const buf3 = new DynamicBuffer();
+    buf3.append('abc');
+    assert.equal(buf.lastIndexOf(buf3), -1);
+  });
+
+  it('Test lastIndexOf with byteOffset parameter.', () => {
+    const buf = new DynamicBuffer();
+    buf.append('ABCABCABC');
+
+    assert.equal(buf.lastIndexOf('ABC'), 6);
+    assert.equal(buf.lastIndexOf('ABC', 0), 0);
+    assert.equal(buf.lastIndexOf('ABC', 1), 0);
+    assert.equal(buf.lastIndexOf('ABC', -1), 6);
+    assert.equal(buf.lastIndexOf('ABC', -9), 0); // -11 equals 0
+    assert.equal(buf.lastIndexOf('ABC', 32), 6);
+    assert.equal(buf.lastIndexOf('', 32), 9);
+  });
+});