ronds-metadata 1.2.37 → 1.2.39

package/es/framework/http/msgpack5/lib/codecs/DateCodec.js

@@ -1,10 +1,8 @@
 var 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
     var encoded = Buffer.allocUnsafe(9);
@@ -19,30 +17,23 @@ function encode(dt) {
   } else {
     // Timestamp32
     var _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) {
   // console.log(buf, 'msgpack');
   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
@@ -50,19 +41,16 @@ function decode(buf) {
       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');
       return undefined;
   }
-
   var millis = seconds * 1000 + Math.round(nanoseconds / 1e6);
   return new Date(millis);
 }
-
 module.exports = {
   check: check,
   type: type,

package/es/framework/http/msgpack5/lib/decoder.js

@@ -32,27 +32,22 @@ var SIZES = {
   0xdc: 3,
   0xdd: 5
 };
-
 function isValidDataSize(dataLength, bufLength, headerLength) {
   return bufLength >= headerLength + dataLength;
 }
-
 export function buildDecode(decodingTypes) {
   return decode;
-
   function decode(buf) {
     // TODO: Make it into ensureBl handler ?
     if (!(buf instanceof bl)) {
       buf = bl().append(buf);
     }
-
-    var result = tryDecode(buf, 0); // Handle worst case ASAP and keep code flat
-
+    var result = tryDecode(buf, 0);
+    // Handle worst case ASAP and keep code flat
     if (!result) throw new IncompleteBufferError();
     buf.consume(result[1]);
     return result[0];
   }
-
   function tryDecode(buf, initialOffset) {
     if (buf.length <= initialOffset) return null;
     var bufLength = buf.length - initialOffset;
@@ -61,206 +56,155 @@ export function buildDecode(decodingTypes) {
     offset += 1;
     var size = SIZES[first] || -1;
     if (bufLength < size) return null;
-
     var inRange = function inRange(start, end) {
       return first >= start && first <= end;
     };
-
     if (first < 0x80) return [first, 1]; // 7-bits positive ints
-
     if ((first & 0xf0) === 0x80) {
       var length = first & 0x0f;
-      var headerSize = offset - initialOffset; // we have an array with less than 15 elements
-
+      var headerSize = offset - initialOffset;
+      // we have an array with less than 15 elements
       return decodeMap(buf, offset, length, headerSize);
     }
-
     if ((first & 0xf0) === 0x90) {
       var _length = first & 0x0f;
-
-      var _headerSize = offset - initialOffset; // we have a map with less than 15 elements
-
-
+      var _headerSize = offset - initialOffset;
+      // we have a map with less than 15 elements
       return decodeArray(buf, offset, _length, _headerSize);
     }
-
     if ((first & 0xe0) === 0xa0) {
       // fixstr up to 31 bytes
       var _length2 = first & 0x1f;
-
       if (!isValidDataSize(_length2, bufLength, 1)) return null;
       var result = buf.toString('utf8', offset, offset + _length2);
       return [result, _length2 + 1];
     }
-
     if (inRange(0xc0, 0xc3)) return decodeConstants(first);
-
     if (inRange(0xc4, 0xc6)) {
       var _length3 = buf.readUIntBE(offset, size - 1);
-
       offset += size - 1;
       if (!isValidDataSize(_length3, bufLength, size)) return null;
-
       var _result = buf.slice(offset, offset + _length3);
-
       return [_result, size + _length3];
     }
-
     if (inRange(0xc7, 0xc9)) {
       var _length4 = buf.readUIntBE(offset, size - 2);
-
       offset += size - 2;
-
       var _type = buf.readInt8(offset);
-
       offset += 1;
       if (!isValidDataSize(_length4, bufLength, size)) return null;
       return decodeExt(buf, offset, _type, _length4, size);
     }
-
     if (inRange(0xca, 0xcb)) return decodeFloat(buf, offset, size - 1);
     if (inRange(0xcc, 0xcf)) return decodeUnsignedInt(buf, offset, size - 1);
     if (inRange(0xd0, 0xd3)) return decodeSigned(buf, offset, size - 1);
-
     if (inRange(0xd4, 0xd8)) {
       var type = buf.readInt8(offset); // Signed
-
       offset += 1;
       return decodeExt(buf, offset, type, size - 2, 2);
     }
-
     if (inRange(0xd9, 0xdb)) {
       var _length5 = buf.readUIntBE(offset, size - 1);
-
       offset += size - 1;
       if (!isValidDataSize(_length5, bufLength, size)) return null;
-
       var _result2 = buf.toString('utf8', offset, offset + _length5);
-
       return [_result2, size + _length5];
     }
-
     if (inRange(0xdc, 0xdd)) {
       var _length6 = buf.readUIntBE(offset, size - 1);
-
       offset += size - 1;
       return decodeArray(buf, offset, _length6, size);
     }
-
     if (inRange(0xde, 0xdf)) {
       var _length7;
-
       switch (first) {
         case 0xde:
           // maps up to 2^16 elements - 2 bytes
           _length7 = buf.readUInt16BE(offset);
-          offset += 2; // console.log(offset - initialOffset)
-
+          offset += 2;
+          // console.log(offset - initialOffset)
           return decodeMap(buf, offset, _length7, 3);
-
         case 0xdf:
           _length7 = buf.readUInt32BE(offset);
           offset += 4;
           return decodeMap(buf, offset, _length7, 5);
       }
     }
-
     if (first >= 0xe0) return [first - 0x100, 1]; // 5 bits negative ints
 
     throw new Error('not implemented yet');
   }
-
   function decodeArray(buf, initialOffset, length, headerLength) {
     var offset = initialOffset;
     var result = [];
     var i = 0;
-
     while (i++ < length) {
       var decodeResult = tryDecode(buf, offset);
       if (!decodeResult) return null;
       result.push(decodeResult[0]);
       offset += decodeResult[1];
     }
-
     return [result, headerLength + offset - initialOffset];
   }
-
   function decodeMap(buf, offset, length, headerLength) {
     var _temp = decodeArray(buf, offset, 2 * length, headerLength);
-
     if (!_temp) return null;
-
     var _temp2 = _slicedToArray(_temp, 2),
-        result = _temp2[0],
-        consumedBytes = _temp2[1];
-
+      result = _temp2[0],
+      consumedBytes = _temp2[1];
     var isPlainObject = true;
-
     for (var i = 0; i < 2 * length; i += 2) {
       if (typeof result[i] !== 'string') {
         isPlainObject = false;
         break;
       }
     }
-
     if (isPlainObject) {
       var object = {};
-
       for (var _i = 0; _i < 2 * length; _i += 2) {
         var key = result[_i];
         var val = result[_i + 1];
         object[key] = val;
       }
-
       return [object, consumedBytes];
     } else {
       var mapping = new Map();
-
       for (var _i2 = 0; _i2 < 2 * length; _i2 += 2) {
         var _key = result[_i2];
         var _val = result[_i2 + 1];
         mapping.set(_key, _val);
       }
-
       return [mapping, consumedBytes];
     }
   }
-
   function readInt64BE(buf, offset) {
     var negate = (buf[offset] & 0x80) == 0x80; // eslint-disable-line
 
     if (negate) {
       var carry = 1;
-
       for (var i = offset + 7; i >= offset; i--) {
         var v = (buf[i] ^ 0xff) + carry;
         buf[i] = v & 0xff;
         carry = v >> 8;
       }
     }
-
     var hi = buf.readUInt32BE(offset + 0);
     var lo = buf.readUInt32BE(offset + 4);
     return (hi * 4294967296 + lo) * (negate ? -1 : +1);
   }
-
   function decodeUnsignedInt(buf, offset, size) {
     var maxOffset = offset + size;
     var result = 0;
-
     while (offset < maxOffset) {
       result += buf.readUInt8(offset++) * Math.pow(256, maxOffset - offset);
     }
-
     return [result, size + 1];
   }
-
   function decodeConstants(first) {
     if (first === 0xc0) return [null, 1];
     if (first === 0xc2) return [false, 1];
     if (first === 0xc3) return [true, 1];
   }
-
   function decodeSigned(buf, offset, size) {
     var result;
     if (size === 1) result = buf.readInt8(offset);
@@ -269,14 +213,12 @@ export function buildDecode(decodingTypes) {
     if (size === 8) result = readInt64BE(buf.slice(offset, offset + 8), 0);
     return [result, size + 1];
   }
-
   function decodeFloat(buf, offset, size) {
     var result;
     if (size === 4) result = buf.readFloatBE(offset);
     if (size === 8) result = buf.readDoubleBE(offset);
     return [result, size + 1];
   }
-
   function decodeExt(buf, offset, type, size, headerSize) {
     var toDecode = buf.slice(offset, offset + size);
     var decode = decodingTypes.get(type);

package/es/framework/http/msgpack5/lib/encoder.js

@@ -14,27 +14,25 @@ export function buildEncode(encodingTypes, options) {
     if (obj === false) return Buffer.from([0xc2]);
     if (obj instanceof Map) return encodeMap(obj, options, encode);
     if (typeof obj === 'string') return encodeString(obj, options);
-
     if (obj && (obj.readUInt32LE || obj instanceof Uint8Array)) {
       if (obj instanceof Uint8Array) {
         obj = Buffer.from(obj);
-      } // weird hack to support Buffer
+      }
+      // weird hack to support Buffer
       // and Buffer-like objects
-
-
       return bl([getBufferHeader(obj.length), obj]);
     }
-
     if (Array.isArray(obj)) return bl().append([getHeader(obj.length, 0x90, 0xdc)].concat(_toConsumableArray(obj.map(encode))));
     if (_typeof(obj) === 'object') return encodeExt(obj, encodingTypes) || encodeObject(obj, options, encode);
     if (typeof obj === 'number') return encodeNumber(obj, options);
     throw new Error('not implemented yet');
   }
-
   return function (obj) {
     return encode(obj).slice();
   };
-} //
+}
+
+//
 //
 // === MENTAL SEPARATOR ===
 //
@@ -42,30 +40,24 @@ export function buildEncode(encodingTypes, options) {
 
 function encodeMap(map, options, encode) {
   var acc = [getHeader(map.size, 0x80, 0xde)];
-
   var keys = _toConsumableArray(map.keys());
-
   if (keys.every(function (item) {
     return typeof item === 'string';
   })) {
     console.warn('Map with string only keys will be deserialized as an object!');
   }
-
   keys.forEach(function (key) {
     acc.push(encode(key), encode(map.get(key)));
   });
   return bl(acc);
 }
-
 function encodeObject(obj, options, encode) {
   var keys = [];
-
   for (var key in obj) {
     if (obj.hasOwnProperty(key) && obj[key] !== undefined && typeof obj[key] !== 'function') {
       keys.push(key);
     }
   }
-
   var acc = [getHeader(keys.length, 0x80, 0xde)];
   if (options.sortKeys) keys.sort();
   keys.forEach(function (key) {
@@ -73,23 +65,22 @@ function encodeObject(obj, options, encode) {
   });
   return bl(acc);
 }
-
 function write64BitUint(buf, offset, num) {
   var lo = num % 4294967296;
   var hi = Math.floor(num / 4294967296);
   buf.writeUInt32BE(hi, offset + 0);
   buf.writeUInt32BE(lo, offset + 4);
 }
-
 function write64BitInt(buf, offset, num) {
   var negate = num < 0;
   num = Math.abs(num);
   write64BitUint(buf, offset, num);
   if (negate) negate64BitInt(buf, offset);
 }
-
 function negate64BitInt(buf, offset) {
-  var i = offset + 8; // Optimization based on the fact that:
+  var i = offset + 8;
+
+  // Optimization based on the fact that:
   // buf[i] == 0x00  => (buf[i] ^ 0xff) + 1 = 0x100 = 0x00 + 1 curry
 
   while (i-- > offset) {
@@ -97,17 +88,13 @@ function negate64BitInt(buf, offset) {
     buf[i] = (buf[i] ^ 0xff) + 1;
     break;
   }
-
   while (i-- > offset) {
     buf[i] = buf[i] ^ 0xff;
   }
 }
-
 var fround = Math.fround;
-
 function encodeFloat(obj, forceFloat64) {
   var buf;
-
   if (forceFloat64 || !fround || fround(obj) !== obj) {
     buf = Buffer.allocUnsafe(9);
     buf[0] = 0xcb;
@@ -117,10 +104,8 @@ function encodeFloat(obj, forceFloat64) {
     buf[0] = 0xca;
     buf.writeFloatBE(obj, 1);
   }
-
   return buf;
 }
-
 function encodeExt(obj, encodingTypes) {
   var codec = encodingTypes.find(function (codec) {
     return codec.check(obj);
@@ -130,7 +115,6 @@ function encodeExt(obj, encodingTypes) {
   if (!encoded) return null;
   return bl([getExtHeader(encoded.length - 1), encoded]);
 }
-
 function getExtHeader(length) {
   if (length === 1) return Buffer.from([0xd4]);
   if (length === 2) return Buffer.from([0xd5]);
@@ -141,7 +125,6 @@ function getExtHeader(length) {
   if (length < 0x10000) return Buffer.from([0xc8, length >> 8, length & 0x00ff]);
   return Buffer.from([0xc9, length >> 24, length >> 16 & 0x000000ff, length >> 8 & 0x000000ff, length & 0x000000ff]);
 }
-
 function getHeader(length, tag1, tag2) {
   if (length < 16) return Buffer.from([tag1 | length]);
   var size = length < 0x10000 ? 2 : 4;
@@ -150,15 +133,12 @@ function getHeader(length, tag1, tag2) {
   buf.writeUIntBE(length, 1, size);
   return buf;
 }
-
 function encodeString(obj, options) {
   var len = Buffer.byteLength(obj);
   var buf;
-
   if (len < 32) {
     buf = Buffer.allocUnsafe(1 + len);
     buf[0] = 0xa0 | len;
-
     if (len > 0) {
       buf.write(obj, 1);
     }
@@ -179,13 +159,10 @@ function encodeString(obj, options) {
     buf.writeUInt32BE(len, 1);
     buf.write(obj, 5);
   }
-
   return buf;
 }
-
 function getBufferHeader(length) {
   var header;
-
   if (length <= 0xff) {
     header = Buffer.allocUnsafe(2);
     header[0] = 0xc4;
@@ -199,18 +176,14 @@ function getBufferHeader(length) {
     header[0] = 0xc6;
     header.writeUInt32BE(length, 1);
   }
-
   return header;
 }
-
 function encodeNumber(obj, options) {
   var buf;
   if (isFloat(obj)) return encodeFloat(obj, options.forceFloat64);
-
   if (Math.abs(obj) > 9007199254740991) {
     return encodeFloat(obj, true);
   }
-
   if (obj >= 0) {
     if (obj < 128) {
       return Buffer.from([obj]);
@@ -247,6 +220,5 @@ function encodeNumber(obj, options) {
       write64BitInt(buf, 1, obj);
     }
   }
-
   return buf;
 }

package/es/framework/http/msgpack5/lib/helpers.js

@@ -1,10 +1,11 @@
 'use strict';
 
-import util from 'util'; // exports.IncompleteBufferError = IncompleteBufferError;
+import util from 'util';
+
+// exports.IncompleteBufferError = IncompleteBufferError;
 
 export function IncompleteBufferError(message) {
   Error.call(this); // super constructor
-
   if (Error.captureStackTrace) {
     Error.captureStackTrace(this, this.constructor); // super helper method to include stack trace in error object
   }

package/es/framework/http/msgpack5/lib/streams.js

@@ -3,7 +3,6 @@
 import { Transform } from 'readable-stream';
 import inherits from 'inherits';
 import bl from 'bl';
-
 function Base(opts) {
   opts = opts || {};
   opts.objectMode = true;
@@ -11,64 +10,50 @@ function Base(opts) {
   Transform.call(this, opts);
   this._msgpack = opts.msgpack;
 }
-
 inherits(Base, Transform);
-
 function Encoder(opts) {
   if (!(this instanceof Encoder)) {
     opts = opts || {};
     opts.msgpack = this;
     return new Encoder(opts);
   }
-
   Base.call(this, opts);
   this._wrap = 'wrap' in opts && opts.wrap;
 }
-
 inherits(Encoder, Base);
-
 Encoder.prototype._transform = function (obj, enc, done) {
   var buf = null;
-
   try {
     buf = this._msgpack.encode(this._wrap ? obj.value : obj).slice(0);
   } catch (err) {
     this.emit('error', err);
     return done();
   }
-
   this.push(buf);
   done();
 };
-
 function Decoder(opts) {
   if (!(this instanceof Decoder)) {
     opts = opts || {};
     opts.msgpack = this;
     return new Decoder(opts);
   }
-
   Base.call(this, opts);
   this._chunks = bl();
   this._wrap = 'wrap' in opts && opts.wrap;
 }
-
 inherits(Decoder, Base);
-
 Decoder.prototype._transform = function (buf, enc, done) {
   if (buf) {
     this._chunks.append(buf);
   }
-
   try {
     var result = this._msgpack.decode(this._chunks);
-
     if (this._wrap) {
       result = {
         value: result
       };
     }
-
     this.push(result);
   } catch (err) {
     if (err instanceof this._msgpack.IncompleteBufferError) {
@@ -76,17 +61,14 @@ Decoder.prototype._transform = function (buf, enc, done) {
     } else {
       this.emit('error', err);
     }
-
     return;
   }
-
   if (this._chunks.length > 0) {
     this._transform(null, enc, done);
   } else {
     done();
   }
 };
-
 export default {
   Decoder: Decoder,
   Encoder: Encoder