feat: add Uint8Array's methods for DynamicBuffer.

Added every, filter, find, findIndex, forEach, join, map,
some, and sort methods.

Author: ghosind

src/dynamicBuffer.ts

@@ -439,6 +439,26 @@ export class DynamicBuffer {
     return this.compare(otherBuffer, 0, otherBuffer.length, 0, this.length) === 0;
   }
 
+  /**
+   * Determines whether all the bytes of the buffer satisfy the specified test.
+   *
+   * @param predicate A function that accepts up to three arguments. The every method calls the
+   * predicate function for each byte in the buffer until the predicate returns a value which is
+   * coercible to the Boolean value false, or until the end of the buffer.
+   * @param thisArg An object to which the this keyword can refer in the predicate function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  every(
+    predicate: (value: number, index: number, array: Uint8Array) => unknown,
+    thisArg?: any,
+  ): boolean {
+    if (!this.buffer || this.length <= 0) {
+      return true;
+    }
+
+    return this.buffer.subarray(0, this.length).every(predicate, thisArg);
+  }
+
   /**
    * Fills this buffer with the specified value, and the entire buffer will be filled if the offset
    * and end are not given.
@@ -474,6 +494,85 @@ export class DynamicBuffer {
     return this;
   }
 
+  /**
+   * Returns the bytes of an array that meet the condition specified in a callback function.
+   *
+   * @param predicate A function that accepts up to three arguments. The filter method calls
+   * the predicate function one time for each byte in the buffer.
+   * @param thisArg An object to which the this keyword can refer in the predicate function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  filter(
+    predicate: (value: number, index: number, array: Uint8Array) => any,
+    thisArg?: any,
+  ): Uint8Array {
+    if (!this.buffer || this.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    return this.buffer.subarray(0, this.length).filter(predicate, thisArg);
+  }
+
+  /**
+   * Returns the value of the first byte in the buffer where predicate is true, and undefined
+   * otherwise.
+   *
+   * @param predicate find calls predicate once for each byte of the buffer, in ascending order,
+   * until it finds one where predicate returns true. If such a byte is found, find immediately
+   * returns that byte. Otherwise, find returns undefined.
+   * @param thisArg If provided, it will be used as the this value for each invocation of
+   * predicate. If it is not provided, undefined is used instead.
+   */
+  find(
+    predicate: (value: number, index: number, obj: Uint8Array) => boolean,
+    thisArg?: any,
+  ): number | undefined {
+    if (!this.buffer || this.length === 0) {
+      return undefined;
+    }
+
+    return this.buffer.subarray(0, this.length).find(predicate, thisArg);
+  }
+
+  /**
+   * Returns the index of the first byte in the buffer where predicate is true, and -1 otherwise.
+   *
+   * @param predicate find calls predicate once for each byte of the buffer, in ascending order,
+   * until it finds one where predicate returns true. If such a byte is found, findIndex
+   * immediately returns that byte position. Otherwise, findIndex returns -1.
+   * @param thisArg If provided, it will be used as the this value for each invocation of
+   * predicate. If it is not provided, undefined is used instead.
+   */
+  findIndex(
+    predicate: (value: number, index: number, obj: Uint8Array) => boolean,
+    thisArg?: any,
+  ): number {
+    if (!this.buffer || this.length === 0) {
+      return -1;
+    }
+
+    return this.buffer.subarray(0, this.length).findIndex(predicate, thisArg);
+  }
+
+  /**
+   * Performs the specified action for each byte in the buffer.
+   *
+   * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn
+   * function one time for each byte in the buffer.
+   * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  forEach(
+    callbackfn: (value: number, index: number, array: Uint8Array) => void,
+    thisArg?: any,
+  ): void {
+    if (!this.buffer || this.length === 0) {
+      return;
+    }
+
+    this.buffer.subarray(0, this.length).forEach(callbackfn, thisArg);
+  }
+
   /**
    * Returns a boolean value to indicate whether this buffer includes a certain value among it.
    *
@@ -526,6 +625,20 @@ export class DynamicBuffer {
     return this.indexOfWithDir(true, value, byteOffset, encoding);
   }
 
+  /**
+   * Adds all the bytes of the buffer separated by the specified separator string.
+   *
+   * @param separator A string used to separate one byte of the buffer from the next in the
+   * resulting String. If omitted, the bytes are separated with a comma.
+   */
+  join(separator?: string): string {
+    if (!this.buffer || this.length === 0) {
+      return '';
+    }
+
+    return this.buffer.subarray(0, this.length).join(separator);
+  }
+
   /**
    * Creates and returns an iterator for keys(indices) in this buffer.
    *
@@ -592,6 +705,26 @@ export class DynamicBuffer {
     return this.indexOfWithDir(false, value, byteOffset, encoding);
   }
 
+  /**
+   * Calls a defined callback function on each byte of the buffer, and returns an array that
+   * contains the results.
+   *
+   * @param callbackfn A function that accepts up to three arguments. The map method calls the
+   * callbackfn function one time for each byte in the buffer.
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  map(
+    callbackfn: (value: number, index: number, array: Uint8Array) => number,
+    thisArg?: any,
+  ): Uint8Array {
+    if (!this.buffer || this.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    return this.buffer.subarray(0, this.length).map(callbackfn, thisArg);
+  }
+
   /**
    * Reads and returns a byte at the position `offset` in this buffer.
    *
@@ -654,6 +787,49 @@ export class DynamicBuffer {
     this.subarray(0, this.length).set(array, offset);
   }
 
+  /**
+   * Determines whether the specified callback function returns true for any byte of the buffer.
+   *
+   * @param predicate A function that accepts up to three arguments. The some method calls the
+   * predicate function for each byte in the buffer until the predicate returns a value which is
+   * coercible to the Boolean value true, or until the end of the buffer.
+   * @param thisArg An object to which the this keyword can refer in the predicate function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  some(
+    predicate: (value: number, index: number, array: Uint8Array) => unknown,
+    thisArg?: any,
+  ): boolean {
+    if (!this.buffer || this.length === 0) {
+      return false;
+    }
+
+    return this.buffer.subarray(0, this.length).some(predicate, thisArg);
+  }
+
+  /**
+   * Sorts all bytes in the buffer.
+   *
+   * ```js
+   * const buf = new DynamicBuffer('cba');
+   * buf.sort();
+   * console.log(buf.toString());
+   * // abc
+   * ```
+   *
+   * @param compareFn Function used to determine the order of the elements. It is expected to
+   * return a negative value if first argument is less than second argument, zero if they're
+   * equal and a positive value otherwise. If omitted, the elements are sorted in ascending order.
+   * @returns The reference of this buffer.
+   */
+  sort(compareFn?: (a: number, b: number) => number): this {
+    if (this.buffer && this.length > 0) {
+      this.buffer.subarray(0, this.length).sort(compareFn);
+    }
+
+    return this;
+  }
+
   /**
    * Returns a new Buffer that references the same memory as the original, but offset and cropped
    * by the start and end indices.
@@ -841,7 +1017,14 @@ export class DynamicBuffer {
   }
 
   /**
-   * The alias of toString().
+   * Decodes buffer to a string with the specified character encoding and range. It's an alias of
+   * toString().
+   *
+   * ```js
+   * const buf = new DynamicBuffer('hello');
+   * console.log(buf.toLocaleString());
+   * // hello
+   * ```
    *
    * @returns The string decodes from buffer
    */

test/array.spec.ts

@@ -3,6 +3,125 @@ import { describe, it } from 'mocha';
 
 import { DynamicBuffer } from '../src';
 
+describe('Every tests', () => {
+  it('Test every', () => {
+    const buf1 = new DynamicBuffer('hello');
+    const buf2 = new DynamicBuffer('Hello');
+
+    assert.equal(buf1.every((v) => v >= 97 && v <= 122), true);
+    assert.equal(buf2.every((v) => v >= 97 && v <= 122), false);
+  });
+
+  it('Test empty buffer\'s every method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.every((v) => v >= 97 && v <= 122), true);
+  });
+});
+
+describe('Filter tests', () => {
+  it('Test filter', () => {
+    const buf = new DynamicBuffer('Hello');
+
+    assert.deepEqual(buf.filter((v) => v >= 97 && v <= 122), new Uint8Array([101, 108, 108, 111]));
+  });
+
+  it('Test empty buffer\'s filter method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.deepEqual(buf.filter((v) => v >= 97 && v <= 122), new Uint8Array());
+  });
+});
+
+describe('Find tests', () => {
+  it('Test find', () => {
+    const buf = new DynamicBuffer('Hello');
+
+    assert.equal(buf.find((v) => v >= 97 && v <= 122), 101);
+    assert.equal(buf.find((v) => v >= 48 && v <= 57), undefined);
+  });
+
+  it('Test empty buffer\'s find method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.find((v) => v >= 97 && v <= 122), undefined);
+  });
+});
+
+describe('FindIndex tests', () => {
+  it('Test findIndex', () => {
+    const buf = new DynamicBuffer('Hello');
+
+    assert.equal(buf.findIndex((v) => v >= 97 && v <= 122), 1);
+    assert.equal(buf.findIndex((v) => v >= 48 && v <= 57), -1);
+  });
+
+  it('Test empty buffer\'s findIndex method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.findIndex((v) => v >= 97 && v <= 122), -1);
+  });
+});
+
+describe('ForEach tests', () => {
+  it('Test forEach', () => {
+    const buf = new DynamicBuffer('Hello');
+    const arr: number[] = [];
+    let called = false;
+
+    buf.forEach((v, i) => {
+      called = true;
+      arr[i] = v;
+    });
+
+    assert.equal(called, true);
+    assert.deepEqual(arr, [72, 101, 108, 108, 111]);
+  });
+
+  it('Test empty buffer\'s forEach method', () => {
+    const buf = new DynamicBuffer();
+    const arr: number[] = [];
+    let called = false;
+
+    buf.forEach((v, i) => {
+      called = true;
+      arr[i] = v;
+    });
+
+    assert.equal(called, false);
+    assert.deepEqual(arr, []);
+  });
+});
+
+describe('Join tests', () => {
+  it('Test join', () => {
+    const buf = new DynamicBuffer('Hello');
+
+    assert.equal(buf.join(), '72,101,108,108,111');
+    assert.equal(buf.join('|'), '72|101|108|108|111');
+  });
+
+  it('Test empty buffer\'s join method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.join(), '');
+  });
+});
+
+describe('Map tests', () => {
+  it('Test map', () => {
+    const buf = new DynamicBuffer('Hello');
+
+    assert.deepEqual(buf.map((v) => v + 1), new Uint8Array([73, 102, 109, 109, 112]));
+  });
+
+  it('Test empty buffer\'s map method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.deepEqual(buf.map((v) => v + 1), new Uint8Array());
+  });
+});
+
 describe('Reverse tests', () => {
   it('Reverse buffer', () => {
     const buf = new DynamicBuffer('hello');
@@ -20,3 +139,39 @@ describe('Reverse tests', () => {
     assert.equal(ref.toString(), '');
   });
 });
+
+describe('Some tests', () => {
+  it('Test some', () => {
+    const buf1 = new DynamicBuffer('HELLO');
+    const buf2 = new DynamicBuffer('Hello');
+
+    assert.equal(buf1.some((v) => v >= 97 && v <= 122), false);
+    assert.equal(buf2.some((v) => v >= 97 && v <= 122), true);
+  });
+
+  it('Test empty buffer\'s some method', () => {
+    const buf = new DynamicBuffer();
+
+    assert.equal(buf.some((v) => v >= 97 && v <= 122), false);
+  });
+});
+
+describe('Sort tests', () => {
+  it('Sort without compare function', () => {
+    const buf = new DynamicBuffer('cba');
+    buf.sort();
+    assert.equal(buf.toString(), 'abc');
+  });
+
+  it('Sort in ascending order', () => {
+    const buf = new DynamicBuffer('cba');
+    buf.sort((a, b) => a - b);
+    assert.equal(buf.toString(), 'abc');
+  });
+
+  it('Sort in descending order', () => {
+    const buf = new DynamicBuffer('abc');
+    buf.sort((a, b) => b - a);
+    assert.equal(buf.toString(), 'cba');
+  });
+});