feat: add iteration methods.

- Add entries method to get an iterator of index-byte pairs.
- Add keys method to get an iterator of indices.
- Add values method to get an iterator of bytes.
- Add test cases for iterations.
- Update eslint rules.

Author: ghosind

.eslintrc.json

@@ -21,6 +21,8 @@
                 ".tx": "never"
             }
         ],
+        "import/prefer-default-export": "off",
+        "max-classes-per-file": "off",
         "no-dupe-class-members": "off",
         "no-unused-vars": "off"
     },

src/dynamicBuffer.ts

@@ -1,5 +1,7 @@
 import { constants } from 'buffer';
 
+import { DynamicBufferIterator } from './iterator';
+
 type BufferEncoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2'
   | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex';
 
@@ -226,6 +228,123 @@ export class DynamicBuffer {
     };
   }
 
+  /**
+   * Creates and returns an iterator of key(index) and value(byte) pairs from this buffer.
+   *
+   * ```js
+   * buf.append('Hello');
+   *
+   * for (const pair of buf.entries()) {
+   *   console.log(pair);
+   * }
+   * // [0, 72]
+   * // [1, 101]
+   * // [2, 108]
+   * // [3, 108]
+   * // [4, 111]
+   *
+   * @returns Iterator of index and byte pairs from this buffer.
+   * ```
+   */
+  entries(): IterableIterator<[number, number]> {
+    return new class extends DynamicBufferIterator<[number, number]> {
+      next(): IteratorResult<[number, number], any> {
+        if (!this.buf.buffer || this.buf.used === this.index) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+
+        const i = this.index;
+        const value = this.buf.buffer[this.index];
+        this.index += 1;
+
+        return {
+          done: false,
+          value: [i, value],
+        };
+      }
+    }(this);
+  }
+
+  /**
+   * Creates and returns an iterator for keys(indices) in this buffer.
+   *
+   * ```js
+   * buf.append('Hello');
+   *
+   * for (const key of buf.keys()) {
+   *   console.log(key);
+   * }
+   * // 0
+   * // 1
+   * // 2
+   * // 3
+   * // 4
+   *
+   * @returns Iterator of buffer keys.
+   * ```
+   */
+  keys(): IterableIterator<number> {
+    return new class extends DynamicBufferIterator<number> {
+      next(): IteratorResult<number, any> {
+        if (!this.buf.buffer || this.buf.used === this.index) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+
+        const value = this.index;
+        this.index += 1;
+
+        return {
+          done: false,
+          value,
+        };
+      }
+    }(this);
+  }
+
+  /**
+   * Creates and returns an iterator for values(bytes) in this buffer.
+   *
+   * ```js
+   * buf.append('Hello');
+   * for (const value of buf.values()) {
+   *   console.log(value);
+   * }
+   * // 72
+   * // 101
+   * // 108
+   * // 108
+   * // 111
+   *
+   * @returns Iterator of buffer values.
+   * ```
+   */
+  values(): IterableIterator<number> {
+    return new class extends DynamicBufferIterator<number> {
+      next(): IteratorResult<number, any> {
+        if (!this.buf.buffer || this.buf.used === this.index) {
+          return {
+            done: true,
+            value: undefined,
+          };
+        }
+
+        const value = this.buf.buffer[this.index];
+        this.index += 1;
+
+        return {
+          done: false,
+          value,
+        };
+      }
+    }(this);
+  }
+
   /**
    * Ensures the buffer size is at least equal to the expect size.
    *

src/iterator.ts

@@ -0,0 +1,29 @@
+import { DynamicBuffer } from '.';
+
+/**
+ * Abstract iterator class for DynamicBuffer.
+ *
+ * ```js
+ * class ValueIterator extends DynamicBufferIterator<number> {
+ *   next() {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+export abstract class DynamicBufferIterator<T> implements IterableIterator<T> {
+  protected buf: DynamicBuffer;
+
+  protected index: number;
+
+  constructor(buf: DynamicBuffer) {
+    this.buf = buf;
+    this.index = 0;
+  }
+
+  [Symbol.iterator](): IterableIterator<T> {
+    return this;
+  }
+
+  abstract next(): IteratorResult<T, any>;
+}

test/dynamicBuffer.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-restricted-syntax */
 import assert from 'assert';
 import { constants } from 'buffer';
 import { describe, it } from 'mocha';
@@ -236,6 +237,78 @@ describe('Exports to JSON object', () => {
   });
 });
 
+describe('Iteration tests', () => {
+  it('Test entries() before writing data', () => {
+    const buf = new DynamicBuffer();
+
+    for (const _ of buf.entries()) {
+      assert.fail('Should not enter loop');
+    }
+  });
+
+  it('Test entires()', () => {
+    const buf = new DynamicBuffer();
+    const str = 'Hello world';
+
+    buf.append(str);
+
+    let index = 0;
+    for (const pair of buf.entries()) {
+      assert.equal(pair[0], index);
+      assert.equal(pair[1], str.charCodeAt(index));
+      index += 1;
+    }
+
+    assert.equal(buf.length, index);
+  });
+
+  it('Test keys() before writing data', () => {
+    const buf = new DynamicBuffer();
+
+    for (const _ of buf.keys()) {
+      assert.fail('Should not enter loop');
+    }
+  });
+
+  it('Test keys()', () => {
+    const buf = new DynamicBuffer();
+    const str = 'Hello world';
+
+    buf.append(str);
+
+    let index = 0;
+    for (const key of buf.keys()) {
+      assert.equal(key, index);
+      index += 1;
+    }
+
+    assert.equal(buf.length, index);
+  });
+
+  it('Test values() before writing data', () => {
+    const buf = new DynamicBuffer();
+
+    for (const _ of buf.values()) {
+      assert.fail('Should not enter loop');
+    }
+  });
+
+  it('Test values()', () => {
+    const buf = new DynamicBuffer();
+    const str = 'Hello world';
+
+    buf.append(str);
+
+    let index = 0;
+    for (const value of buf.values()) {
+      assert.equal(value, str.charCodeAt(index));
+      index += 1;
+    }
+
+    assert.equal(buf.length, index);
+  });
+});
+
 describe('Resize tests', () => {
   it('Test resize()', () => {
     const buffer = new DynamicBuffer();