msgpackr 1.8.0 → 1.8.2

package/dist/test.js

@@ -118,7 +118,7 @@
 				let size = source.length;
 				let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
 				if (forEach) {
-					forEach(value);
+					if (forEach(value) === false) return;
 					while(position$1 < size) {
 						lastPosition = position$1;
 						if (forEach(checkedRead()) === false) {
@@ -1168,7 +1168,7 @@
 			if (maxSharedStructures > 8160)
 				throw new Error('Maximum maxSharedStructure is 8160')
 			if (options.structuredClone && options.moreTypes == undefined) {
-				options.moreTypes = true;
+				this.moreTypes = true;
 			}
 			let maxOwnStructures = options.maxOwnStructures;
 			if (maxOwnStructures == null)
@@ -1329,6 +1329,23 @@
 						position = start;
 				}
 			};
+			const packArray = (value) => {
+				var length = value.length;
+				if (length < 0x10) {
+					target[position++] = 0x90 | length;
+				} else if (length < 0x10000) {
+					target[position++] = 0xdc;
+					target[position++] = length >> 8;
+					target[position++] = length & 0xff;
+				} else {
+					target[position++] = 0xdd;
+					targetView.setUint32(position, length);
+					position += 4;
+				}
+				for (let i = 0; i < length; i++) {
+					pack(value[i]);
+				}
+			};
 			const pack = (value) => {
 				if (position > safeEnd)
 					target = makeRoom(position);
@@ -1511,22 +1528,8 @@
 						let constructor = value.constructor;
 						if (constructor === Object) {
 							writeObject(value, true);
-						} else if (constructor === Array || Array.isArray(value)) {
-							length = value.length;
-							if (length < 0x10) {
-								target[position++] = 0x90 | length;
-							} else if (length < 0x10000) {
-								target[position++] = 0xdc;
-								target[position++] = length >> 8;
-								target[position++] = length & 0xff;
-							} else {
-								target[position++] = 0xdd;
-								targetView.setUint32(position, length);
-								position += 4;
-							}
-							for (let i = 0; i < length; i++) {
-								pack(value[i]);
-							}
+						} else if (constructor === Array) {
+							packArray(value);
 						} else if (constructor === Map) {
 							length = value.size;
 							if (length < 0x10) {
@@ -1555,7 +1558,16 @@
 											target[position++] = extension.type;
 											target[position++] = 0;
 										}
-										pack(extension.write.call(this, value));
+										let writeResult = extension.write.call(this, value);
+										if (writeResult === value) { // avoid infinite recursion
+											if (Array.isArray(value)) {
+												packArray(value);
+											} else {
+												writeObject(value);
+											}
+										} else {
+											pack(writeResult);
+										}
 										return
 									}
 									let currentTarget = target;
@@ -1592,8 +1604,13 @@
 									return
 								}
 							}
-							// no extension found, write as object
-							writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
+							// check isArray after extensions, because extensions can extend Array
+							if (Array.isArray(value)) {
+								packArray(value);
+							} else {
+								// no extension found, write as object
+								writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
+							}
 						}
 					}
 				} else if (type === 'boolean') {
@@ -1846,12 +1863,11 @@
 					if (notifySharedUpdate)
 						return hasSharedUpdate = true;
 					position = newPosition;
-					if (start > 0) {
-						pack(value);
-						if (start == 0)
-							return { position, targetView, target }; // indicate the buffer was re-allocated
-					} else
-						pack(value);
+					let startTarget = target;
+					pack(value);
+					if (startTarget !== target) {
+						return { position, targetView, target }; // indicate the buffer was re-allocated
+					}
 					return position;
 				}, this);
 				if (newPosition === 0) // bail and go to a msgpack object
@@ -2769,24 +2785,35 @@
 				let objectLiteralProperties = [];
 				let args = [];
 				let i = 0;
+				let hasInheritedProperties;
 				for (let property of properties) { // assign in enumeration order
+					if (unpackr.alwaysLazyProperty && unpackr.alwaysLazyProperty(property.key)) {
+						// these properties are not eagerly evaluated and this can be used for creating properties
+						// that are not serialized as JSON
+						hasInheritedProperties = true;
+						continue;
+					}
 					Object.defineProperty(prototype, property.key, { get: withSource(property.get), enumerable: true });
 					let valueFunction = 'v' + i++;
 					args.push(valueFunction);
 					objectLiteralProperties.push('[' + JSON.stringify(property.key) + ']:' + valueFunction + '(s)');
 				}
+				if (hasInheritedProperties) {
+					objectLiteralProperties.push('__proto__:this');
+				}
 				let toObject = (new Function(...args, 'return function(s){return{' + objectLiteralProperties.join(',') + '}}')).apply(null, properties.map(prop => prop.get));
 				Object.defineProperty(prototype, 'toJSON', {
-					value() {
-						return toObject(this[sourceSymbol]);
+					value(omitUnderscoredProperties) {
+						return toObject.call(this, this[sourceSymbol]);
 					}
 				});
 			} else {
 				Object.defineProperty(prototype, 'toJSON', {
-					value() {
+					value(omitUnderscoredProperties) {
 						// return an enumerable object with own properties to JSON stringify
 						let resolved = {};
 						for (let i = 0, l = properties.length; i < l; i++) {
+							// TODO: check alwaysLazyProperty
 							let key = properties[i].key;
 
 							resolved[key] = this[key];
@@ -2920,6 +2947,20 @@
 
 	var ITERATIONS = 4000;
 
+	class ExtendArray extends Array {
+	}
+
+	class ExtendArray2 extends Array {
+	}
+
+	class ExtendArray3 extends Array {
+	}
+
+
+	class ExtendObject {
+	}
+
+
 	suite('msgpackr basic tests', function() {
 		test('pack/unpack data', function () {
 			var data = {
@@ -3187,6 +3228,73 @@
 			assert.deepEqual(data, deserialized);
 			assert.equal(deserialized.extendedInstance.getDouble(), 8);
 		});
+
+		test('extended Array class read/write', function(){
+			var instance = new ExtendArray();
+			instance.push(0);
+			instance.push(1);
+			instance.push(2);
+			var data = {
+				prop1: 'has multi-byte: ᾜ',
+				extendedInstance: instance,
+				prop2: 'more string',
+				num: 3,
+			};
+			new Packr();
+			addExtension({
+				Class: ExtendArray,
+				type: 12,
+				read: function(data) {
+					Object.setPrototypeOf(data, ExtendArray.prototype);
+					return data
+				},
+				write: function(instance) {
+					return [...instance]
+				}
+			});
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.strictEqual(Object.getPrototypeOf(deserialized.extendedInstance), ExtendArray.prototype);
+			assert.deepEqual(data, deserialized);
+		});
+
+
+		test('unregistered extended Array class read/write', function(){
+			var instance = new ExtendArray2();
+			instance.push(0);
+			instance.push(1);
+			instance.push(2);
+			var data = {
+				prop1: 'has multi-byte: ᾜ',
+				extendedInstance: instance,
+				prop2: 'more string',
+				num: 3,
+			};
+			new Packr();
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.strictEqual(Object.getPrototypeOf(deserialized.extendedInstance), Array.prototype);
+			assert.deepEqual(data, deserialized);
+		});
+
+
+		test('unregistered extended Object class read/write', function(){
+			var instance = new ExtendObject();
+			instance.test1 = "string";
+			instance.test2 = 3421321;
+			var data = {
+				prop1: 'has multi-byte: ᾜ',
+				extendedInstance: instance,
+				prop2: 'more string',
+				num: 3,
+			};
+			new Packr();
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.strictEqual(Object.getPrototypeOf(deserialized.extendedInstance), Object.prototype);
+			assert.deepEqual(data, deserialized);
+		});
+
 		test('extended class pack/unpack custom size', function(){
 			function TestClass() {
 
@@ -3240,6 +3348,69 @@
 			assert.deepEqual(data, deserialized);
 			assert.equal(deserialized.extendedInstance.getDouble(), 8);
 		});
+		test('extended class return self', function(){
+			function Extended() {
+
+			}
+			Extended.prototype.getDouble = function() {
+				return this.value * 2
+			};
+			var instance = new Extended();
+			instance.value = 4;
+			instance.string = 'decode this: ᾜ';
+			var data = {
+				prop1: 'has multi-byte: ᾜ',
+				extendedInstance: instance,
+				prop2: 'more string',
+				num: 3,
+			};
+			new Packr();
+			addExtension({
+				Class: Extended,
+				type: 13,
+				read: function(data) {
+					Object.setPrototypeOf(data, Extended.prototype);
+					return data
+				},
+				write: function(data) {
+					return data
+				}
+			});
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.deepEqual(data, deserialized);
+			assert.strictEqual(Object.getPrototypeOf(deserialized.extendedInstance), Extended.prototype);
+			assert.equal(deserialized.extendedInstance.getDouble(), 8);
+		});
+		test('extended Array class return self', function(){
+			var instance = new ExtendArray3();
+			instance.push(0);
+			instance.push('has multi-byte: ᾜ');
+			var data = {
+				prop1: 'has multi-byte: ᾜ',
+				extendedInstance: instance,
+				prop2: 'more string',
+				num: 3,
+			};
+			new Packr();
+			addExtension({
+				Class: ExtendArray3,
+				type: 14,
+				read: function(data) {
+					Object.setPrototypeOf(data, ExtendArray3.prototype);
+					return data
+				},
+				write: function(data) {
+					return data
+				}
+			});
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.deepEqual(data, deserialized);
+			assert.strictEqual(Object.getPrototypeOf(deserialized.extendedInstance), ExtendArray3.prototype);
+			assert.equal(deserialized.extendedInstance[0], 0);
+		});
+
 		test('proto handling', function() {
 			var objectWithProto = JSON.parse('{"__proto__":{"foo":3}}');
 			var decoded = unpack(pack(objectWithProto));