Improve internals and add some features

README.md

@@ -107,6 +107,7 @@ encoded.
 options:
 
 - `forceFloat64`, a boolean to that forces all floats to be encoded as 64-bits floats. Defaults to false.
+- `sortKeys`, a boolean to force a determinate keys order
 - `compatibilityMode`, a boolean that enables "compatibility mode" which doesn't use str 8 format. Defaults to false.
 - `disableTimestampEncoding`, a boolean that when set disables the encoding of Dates into the [timestamp extension type](https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type). Defaults to false.
 

index.js

@@ -7,10 +7,11 @@ var streams = require('./lib/streams')
 var buildDecode = require('./lib/decoder')
 var buildEncode = require('./lib/encoder')
 var IncompleteBufferError = require('./lib/helpers.js').IncompleteBufferError
+var DateCodec = require('./lib/codecs/DateCodec')
 
 function msgpack (options) {
   var encodingTypes = []
-  var decodingTypes = Object.create(null)
+  var decodingTypes = new Map()
 
   options = options || {
     forceFloat64: false,
@@ -20,6 +21,11 @@ function msgpack (options) {
     disableTimestampEncoding: false
   }
 
+  decodingTypes.set(DateCodec.type, DateCodec.decode)
+  if (!options.disableTimestampEncoding) {
+    encodingTypes.push(DateCodec)
+  }
+
   function registerEncoder (check, encode) {
     assert(check, 'must have an encode function')
     assert(encode, 'must have an encode function')
@@ -32,7 +38,7 @@ function msgpack (options) {
   function registerDecoder (type, decode) {
     assert(type >= 0, 'must have a non-negative type')
     assert(decode, 'must have a decode function')
-    decodingTypes[type] = decode
+    decodingTypes.set(type, decode)
     return this
   }
 
@@ -65,7 +71,7 @@ function msgpack (options) {
   }
 
   return {
-    encode: buildEncode(encodingTypes, options.forceFloat64, options.compatibilityMode, options.disableTimestampEncoding),
+    encode: buildEncode(encodingTypes, options),
     decode: buildDecode(decodingTypes),
     register,
     registerEncoder,

lib/codecs/DateCodec.js

@@ -0,0 +1,62 @@
+const type = -1
+
+function encode (dt) {
+  var millis = dt * 1
+  var seconds = Math.floor(millis / 1000)
+  var nanos = (millis - seconds * 1000) * 1e6
+
+  if (nanos || seconds > 0xffffffff) {
+    // Timestamp64
+    const encoded = Buffer.allocUnsafe(9)
+    encoded[0] = -1
+
+    var upperNanos = nanos * 4
+    var upperSeconds = seconds / Math.pow(2, 32)
+    var upper = (upperNanos + upperSeconds) & 0xffffffff
+    var lower = seconds & 0xffffffff
+
+    encoded.writeInt32BE(upper, 1)
+    encoded.writeInt32BE(lower, 5)
+    return encoded
+  } else {
+    // Timestamp32
+    const encoded = Buffer.allocUnsafe(5)
+    encoded[0] = -1
+    encoded.writeUInt32BE(Math.floor(millis / 1000), 1)
+    return encoded
+  }
+}
+
+function check (obj) {
+  return typeof obj.getDate === 'function'
+}
+
+function decode (buf) {
+  var seconds
+  var nanoseconds = 0
+
+  switch (buf.length) {
+    case 4:
+      // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
+      seconds = buf.readUInt32BE(0)
+      break
+
+    case 8:
+      // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
+      // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
+      var upper = buf.readUInt32BE(0)
+      var lower = buf.readUInt32BE(4)
+      nanoseconds = upper / 4
+      seconds = ((upper & 0x03) * Math.pow(2, 32)) + lower // If we use bitwise operators, we get truncated to 32bits
+      break
+
+    case 12:
+      throw new Error('timestamp 96 is not yet implemented')
+  }
+
+  var millis = (seconds * 1000) + Math.round(nanoseconds / 1E6)
+
+  return new Date(millis)
+}
+
+module.exports = { check, type, encode, decode }

lib/decoder.js

@@ -1,9 +1,7 @@
 'use strict'
 
 var bl = require('bl')
-var helpers = require('./helpers.js')
-var IncompleteBufferError = helpers.IncompleteBufferError
-var decodeTimestamp = helpers.decodeTimestamp
+var IncompleteBufferError = require('./helpers.js').IncompleteBufferError
 
 const SIZES = {
   0xc4: 2,
@@ -75,7 +73,7 @@ module.exports = function buildDecode (decodingTypes) {
       const length = first & 0x0f
       const headerSize = offset - initialOffset
       // we have an array with less than 15 elements
-      return decodeMap(buf, initialOffset, length, headerSize)
+      return decodeMap(buf, offset, length, headerSize)
     }
     if ((first & 0xf0) === 0x90) {
       const length = first & 0x0f
@@ -140,12 +138,12 @@ module.exports = function buildDecode (decodingTypes) {
           length = buf.readUInt16BE(offset)
           offset += 2
           // console.log(offset - initialOffset)
-          return decodeMap(buf, initialOffset, length, 3)
+          return decodeMap(buf, offset, length, 3)
 
         case 0xdf:
           length = buf.readUInt32BE(offset)
           offset += 4
-          return decodeMap(buf, initialOffset, length, 5)
+          return decodeMap(buf, offset, length, 5)
       }
     }
     if (first >= 0xe0) return [first - 0x100, 1] // 5 bits negative ints
@@ -168,24 +166,36 @@ module.exports = function buildDecode (decodingTypes) {
     return [result, headerLength + offset - initialOffset]
   }
 
-  function decodeMap (buf, initialOffset, length, headerLength) {
-    var offset = initialOffset + headerLength
-    const result = {}
-    var i = 0
-
-    while (i++ < length) {
-      var keyResult = tryDecode(buf, offset)
-      if (!keyResult) return null
-      offset += keyResult[1]
+  function decodeMap (buf, offset, length, headerLength) {
+    const _temp = decodeArray(buf, offset, 2 * length, headerLength)
+    if (!_temp) return null
+    const [ result, consumedBytes ] = _temp
 
-      var valueResult = tryDecode(buf, offset)
-      if (!valueResult) return null
-      offset += valueResult[1]
-
-      result[keyResult[0]] = valueResult[0]
+    var isPlainObject = true
+    for (let i = 0; i < 2 * length; i += 2) {
+      if (typeof result[i] !== 'string') {
+        isPlainObject = false
+        break
+      }
     }
 
-    return [result, offset - initialOffset]
+    if (isPlainObject) {
+      const object = {}
+      for (let i = 0; i < 2 * length; i += 2) {
+        const key = result[i]
+        const val = result[i + 1]
+        object[key] = val
+      }
+      return [object, consumedBytes]
+    } else {
+      const mapping = new Map()
+      for (let i = 0; i < 2 * length; i += 2) {
+        const key = result[i]
+        const val = result[i + 1]
+        mapping.set(key, val)
+      }
+      return [mapping, consumedBytes]
+    }
   }
 
   function readInt64BE (buf, offset) {
@@ -237,10 +247,7 @@ module.exports = function buildDecode (decodingTypes) {
   function decodeExt (buf, offset, type, size, headerSize) {
     const toDecode = buf.slice(offset, offset + size)
 
-    // Pre-defined  (type < 0) Reserved for future extensions
-    if (type === -1) return decodeTimestamp(toDecode, size, headerSize)
-
-    const decode = decodingTypes[type]
+    const decode = decodingTypes.get(type)
     if (!decode) throw new Error('unable to find ext type ' + type)
 
     var value = decode(toDecode)