Merge to master

package.json

@@ -1,13 +1,12 @@
 {
   "name": "ginkgoch-buffer-io",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "main": "dist/bundle.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/ginkgoch/node-buffer-io",
   "scripts": {
     "test": "jest",
-    "build": "rm -rf built && ./node_modules/.bin/tsc --build tsconfig.json",
-    "build-prod": "rm -rf dist && ./node_modules/.bin/webpack",
+    "build": "rm -rf dist && ./node_modules/.bin/webpack",
     "clean": "rm -rf built && rm -rf dist"
   },
   "author": {

src/reader.ts

@@ -1,22 +1,23 @@
 import assert from 'assert';
+import calcOffset from './shared';
 
 export default class BufferReader {
     buffer: Buffer;
-    offset: number;
+    position: number;
 
     constructor(buffer: Buffer) {
         assert(Buffer.isBuffer(buffer), 'Invalid buffer.');
         this.buffer = buffer;
-        this.offset = 0;
+        this.position = 0;
     }
 
-    seek(offset: number, fromBeginning = true) {
-        if(!fromBeginning) {
-            offset += this.offset;
-        }
-
-        this._checkOffsetInRange(offset);
-        this.offset = offset;
+    /**
+     * 
+     * @param offset The offset to seek.
+     * @param origin The seek origin. True means seeking from begining. False means seeking from current position. Default is True.
+     */
+    seek(offset: number, origin: boolean | 'begin' | 'current' | 'end' = true) {
+        this.position = calcOffset(offset, this.position, this.buffer.length, origin);
     }
 
     nextDouble(): number {
@@ -26,7 +27,7 @@ export default class BufferReader {
     nextDoubleLE(): number {
         return this._nextXX('DoubleLE', 8);
     }
-    
+
     nextDoubleBE(): number {
         return this._nextXX('DoubleBE', 8);
     }
@@ -38,7 +39,7 @@ export default class BufferReader {
     nextFloatLE(): number {
         return this._nextXX('FloatLE', 4);
     }
-    
+
     nextFloatBE(): number {
         return this._nextXX('FloatBE', 4);
     }
@@ -50,7 +51,7 @@ export default class BufferReader {
     nextInt32LE(): number {
         return this._nextXX('Int32LE', 4);
     }
-    
+
     nextInt32BE(): number {
         return this._nextXX('Int32BE', 4);
     }
@@ -62,7 +63,7 @@ export default class BufferReader {
     nextUInt32LE(): number {
         return this._nextXX('UInt32LE', 4);
     }
-    
+
     nextUInt32BE(): number {
         return this._nextXX('UInt32BE', 4);
     }
@@ -74,7 +75,7 @@ export default class BufferReader {
     nextUInt16LE(): number {
         return this._nextXX('UInt16LE', 2);
     }
-    
+
     nextUInt16BE(): number {
         return this._nextXX('UInt16BE', 2);
     }
@@ -86,7 +87,7 @@ export default class BufferReader {
     nextInt16LE(): number {
         return this._nextXX('Int16LE', 2);
     }
-    
+
     nextInt16BE(): number {
         return this._nextXX('Int16BE', 2);
     }
@@ -101,27 +102,27 @@ export default class BufferReader {
 
     nextBuffer(length: number): Buffer {
         this._checkPositive(length);
-        this._checkOffsetInRange(this.offset + length);
+        this._checkOffsetInRange(this.position + length);
 
-        const buffer = this.buffer.slice(this.offset, this.offset + length);
-        this.offset += length;
+        const buffer = this.buffer.slice(this.position, this.position + length);
+        this.position += length;
         return buffer;
     }
 
     nextString(length: number, encoding = 'utf-8'): string {
         this._checkPositive(length);
-        this._checkOffsetInRange(this.offset + length);
-        const str = this.buffer.toString(encoding, this.offset, this.offset + length);
-        this.offset += length;
+        this._checkOffsetInRange(this.position + length);
+        const str = this.buffer.toString(encoding, this.position, this.position + length);
+        this.position += length;
         return str;
     }
 
     private _nextXX(type: string, size: number): any {
-        this._checkOffsetInRange(this.offset + size);
+        this._checkOffsetInRange(this.position + size);
 
         const methodName = `read${type}`;
-        const v = this.buffer[methodName](this.offset);
-        this.offset += size;
+        const v = this.buffer[methodName](this.position);
+        this.position += size;
         return v;
     }
 

src/shared.ts

@@ -0,0 +1,20 @@
+import assert from 'assert';
+
+export default function (offset: number, current: number, length: number, origin: boolean | 'begin' | 'end' | 'current' = true): number {
+    if (typeof origin === 'boolean') {
+        if (!origin) {
+            offset += current;
+        }
+    }
+    else {
+        if (origin === 'current') {
+            offset += current;
+        }
+        else if (origin === 'end') {
+            offset = length - offset;
+        }
+    }
+
+    assert(offset >= 0 && offset <= length, 'Offset out of range.');
+    return offset;
+}

src/writer.ts

@@ -1,8 +1,9 @@
 import assert from 'assert';
+import calcOffset from './shared';
 
 export default class BufferWriter {
     buffer: Buffer;
-    offset: number;
+    position: number;
 
     /**
      *
@@ -12,16 +13,16 @@ export default class BufferWriter {
         assert(Buffer.isBuffer(buffer), 'Invalid buffer.');
 
         this.buffer = buffer
-        this.offset = 0
+        this.position = 0
     }
 
-    seek(offset: number, fromBeginning = true) {
-        if(!fromBeginning) {
-            offset += this.offset
-        }
-
-        this._checkOffsetInRange(offset)
-        this.offset = offset
+    /**
+     * 
+     * @param offset The offset to seek.
+     * @param origin The seek origin. True means seeking from begining. False means seeking from current position. Default is True.
+     */
+    seek(offset: number, origin: boolean | 'begin' | 'current' | 'end' = true) {
+        this.position = calcOffset(offset, this.position, this.buffer.length, origin);
     }
 
     writeDouble(value: number): number {
@@ -107,21 +108,21 @@ export default class BufferWriter {
     writeBuffer(buffer: Buffer): number {
         assert(buffer, 'Buffer cannot be null.')
 
-        buffer.copy(this.buffer, this.offset)
-        this.offset += buffer.length
-        return this.offset
+        buffer.copy(this.buffer, this.position)
+        this.position += buffer.length
+        return this.position
     }
 
     writeString(str: string, encoding: BufferEncoding = 'utf-8') {
-        let length = this.buffer.length - this.offset
-        this.offset = this.buffer.write(str, this.offset, length, encoding)
-        return this.offset
+        let length = this.buffer.length - this.position
+        this.position += this.buffer.write(str, this.position, length, encoding)
+        return this.position
 
     }
 
     _writeXX(type: string, value: number): number {
-        this.offset = this.buffer[`write${type}`](value, this.offset)
-        return this.offset
+        this.position = this.buffer[`write${type}`](value, this.position)
+        return this.position
     }
 
     _checkPositive(number: number, name = 'Length') {

tests/reader.test.ts

@@ -17,24 +17,24 @@ describe('buffer reader tests', () => {
     test('seek from beginning - normal', () => {
         const buffer = Buffer.from([1, 2, 3, 4]);
         const br = new BufferReader(buffer);
-        expect(br.offset).toBe(0);
+        expect(br.position).toBe(0);
         expect(br.buffer).not.toBeNull();
         expect(br.buffer).not.toBeUndefined();
         br.seek(2);
-        expect(br.offset).toBe(2);
+        expect(br.position).toBe(2);
     });
 
     test('seek from current - normal', () => {
         const buffer = Buffer.from([1, 2, 3, 4]);
         const br = new BufferReader(buffer);
         br.seek(1);
-        expect(br.offset).toBe(1);
+        expect(br.position).toBe(1);
         br.seek(1, false);
-        expect(br.offset).toBe(2);
+        expect(br.position).toBe(2);
         br.seek(1, false);
-        expect(br.offset).toBe(3);
+        expect(br.position).toBe(3);
         br.seek(1);
-        expect(br.offset).toBe(1);
+        expect(br.position).toBe(1);
     });
 
     test('seek from beginning - out of range', () => {

tests/writer.test.ts

@@ -7,11 +7,11 @@ describe('BufferWriter tests', () => {
         const bw = new BufferWriter(buffer)
         let offset = bw.writeDoubleLE(16.9)
         expect(offset).toBe(8)
-        expect(offset).toBe(bw.offset)
+        expect(offset).toBe(bw.position)
 
         offset = bw.writeDoubleLE(67.9)
         expect(offset).toBe(16)
-        expect(offset).toBe(bw.offset)
+        expect(offset).toBe(bw.position)
     })
 
     it('WriteBuffer', () => {
@@ -22,12 +22,12 @@ describe('BufferWriter tests', () => {
         const bw = new BufferWriter(buffer)
         let offset = bw.writeBuffer(target1)
         expect(offset).toBe(6)
-        expect(offset).toBe(bw.offset)
+        expect(offset).toBe(bw.position)
         expect(buffer.length).toBe(256)
 
         offset = bw.writeBuffer(target2)
         expect(offset).toBe(12)
-        expect(offset).toBe(bw.offset)
+        expect(offset).toBe(bw.position)
 
         const bufferSlice = buffer.slice(0, 12)
         const bufferConcat = Buffer.concat([target1, target2])
@@ -69,4 +69,25 @@ describe('BufferWriter tests', () => {
         expect(i3).toBe(32)
         expect(i4).toBe(54.8765)
     })
+
+    it('position - write', () => {
+        const buffer = Buffer.alloc(256);
+        const bw = new BufferWriter(buffer);
+        expect(bw.position).toBe(0);
+
+        bw.writeUInt8(2);
+        expect(bw.position).toBe(1);
+
+        bw.writeUInt8(3);
+        expect(bw.position).toBe(2);
+
+        bw.writeString('hello');
+        expect(bw.position).toBe(7);
+
+        bw.writeString('hello');
+        expect(bw.position).toBe(12);
+
+        bw.writeBuffer(Buffer.from([4, 5]));
+        expect(bw.position).toBe(14);
+    });
 })

tsconfig.json

@@ -63,6 +63,6 @@
     "suppressImplicitAnyIndexErrors": true
   },
   "exclude": [
-    "node_modules", "tests"
+    "node_modules", "tests", "dist"
   ]
 }