compact-encoding 2.12.0 → 2.14.0

package/README.md

@@ -99,6 +99,8 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.float64` - Encodes a fixed size float64.
 * `cenc.buffer` - Encodes a buffer with its length uint prefixed. When decoding an empty buffer, `null` is returned.
 * `cenc.raw.buffer` - Encodes a buffer without a length prefixed.
+* `cenc.arraybuffer` - Encodes an arraybuffer with its length uint prefixed.
+* `cenc.raw.arraybuffer` - Encodes an arraybuffer without a length prefixed.
 * `cenc.uint8array` - Encodes a uint8array with its element length uint prefixed.
 * `cenc.raw.uint8array` - Encodes a uint8array without a length prefixed.
 * `cenc.uint16array` - Encodes a uint16array with its element length uint prefixed.

package/index.js

@@ -241,6 +241,31 @@ exports.binary = {
   }
 }
 
+exports.arraybuffer = {
+  preencode (state, b) {
+    uint.preencode(state, b.byteLength)
+    state.end += b.byteLength
+  },
+  encode (state, b) {
+    uint.encode(state, b.byteLength)
+
+    const view = new Uint8Array(b)
+
+    state.buffer.set(view, state.start)
+    state.start += b.byteLength
+  },
+  decode (state) {
+    const len = uint.decode(state)
+
+    const b = new ArrayBuffer(len)
+    const view = new Uint8Array(b)
+
+    view.set(state.buffer.subarray(state.start, state.start += len))
+
+    return b
+  }
+}
+
 function typedarray (TypedArray, swap) {
   const n = TypedArray.BYTES_PER_ELEMENT
 
@@ -378,6 +403,33 @@ exports.array = function array (enc) {
   }
 }
 
+exports.frame = function frame (enc) {
+  const dummy = exports.state()
+
+  return {
+    preencode (state, m) {
+      const end = state.end
+      enc.preencode(state, m)
+      uint.preencode(state, state.end - end)
+    },
+    encode (state, m) {
+      dummy.end = 0
+      enc.preencode(dummy, m)
+      uint.encode(state, dummy.end)
+      enc.encode(state, m)
+    },
+    decode (state) {
+      const end = state.end
+      const len = uint.decode(state)
+      state.end = state.start + len
+      const m = enc.decode(state)
+      state.start = state.end
+      state.end = end
+      return m
+    }
+  }
+}
+
 exports.json = {
   preencode (state, v) {
     utf8.preencode(state, JSON.stringify(v))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compact-encoding",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "A series of compact encoding schemes for building small and fast parsers and serializers",
   "main": "index.js",
   "dependencies": {

package/raw.js

@@ -46,6 +46,28 @@ exports.binary = {
   }
 }
 
+exports.arraybuffer = {
+  preencode (state, b) {
+    state.end += b.byteLength
+  },
+  encode (state, b) {
+    const view = new Uint8Array(b)
+
+    state.buffer.set(view, state.start)
+    state.start += b.byteLength
+  },
+  decode (state) {
+    const b = new ArrayBuffer(state.end - state.start)
+    const view = new Uint8Array(b)
+
+    view.set(state.buffer.subarray(state.start))
+
+    state.start = state.end
+
+    return b
+  }
+}
+
 function typedarray (TypedArray, swap) {
   const n = TypedArray.BYTES_PER_ELEMENT
 

package/test.js

@@ -173,6 +173,34 @@ test('buffer', function (t) {
   t.exception(() => enc.buffer.decode(state))
 })
 
+test('arraybuffer', function (t) {
+  const state = enc.state()
+
+  const b1 = new ArrayBuffer(4)
+  b4a.from(b1).fill('a')
+
+  const b2 = new ArrayBuffer(8)
+  b4a.from(b2).fill('b')
+
+  enc.arraybuffer.preencode(state, b1)
+  t.alike(state, enc.state(0, 5))
+  enc.arraybuffer.preencode(state, b2)
+  t.alike(state, enc.state(0, 14))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.arraybuffer.encode(state, b1)
+  t.alike(state, enc.state(5, 14, b4a.from('\x04aaaa\x00\x00\x00\x00\x00\x00\x00\x00\x00')))
+  enc.arraybuffer.encode(state, b2)
+  t.alike(state, enc.state(14, 14, b4a.from('\x04aaaa\x08bbbbbbbb')))
+
+  state.start = 0
+  t.alike(enc.arraybuffer.decode(state), b1)
+  t.alike(enc.arraybuffer.decode(state), b2)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.arraybuffer.decode(state))
+})
+
 test('raw', function (t) {
   const state = enc.state()
 
@@ -671,3 +699,11 @@ test('any', function (t) {
 
   t.alike(enc.decode(enc.any, enc.encode(enc.any, arr)), [null, null, null])
 })
+
+test('framed', function (t) {
+  const e = enc.frame(enc.uint)
+  t.alike(enc.encode(e, 42), b4a.from([0x01, 0x2a]))
+  t.alike(enc.decode(e, b4a.from([0x01, 0x2a])), 42)
+  t.alike(enc.encode(e, 4200), b4a.from([0x03, 0xfd, 0x68, 0x10]))
+  t.alike(enc.decode(e, b4a.from([0x03, 0xfd, 0x68, 0x10])), 4200)
+})