msgpackr 1.9.1 → 1.9.3

package/dist/test.js

@@ -120,10 +120,10 @@
 				let size = source.length;
 				let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
 				if (forEach) {
-					if (forEach(value) === false) return;
+					if (forEach(value, lastPosition, position$1) === false) return;
 					while(position$1 < size) {
 						lastPosition = position$1;
-						if (forEach(checkedRead()) === false) {
+						if (forEach(checkedRead(), lastPosition, position$1) === false) {
 							return
 						}
 					}
@@ -197,6 +197,10 @@
 				position$1 = bundledStrings$1.postBundlePosition;
 				bundledStrings$1 = null;
 			}
+			if (sequentialMode)
+				// we only need to restore the structures if there was an error, but if we completed a read,
+				// we can clear this out and keep the structures we read
+				currentStructures.restoreStructures = null;
 
 			if (position$1 == srcEnd) {
 				// finished reading this source, cleanup references
@@ -967,7 +971,10 @@
 			structure.highByte = highByte;
 		}
 		let existingStructure = currentStructures[id];
-		if (existingStructure && existingStructure.isShared) {
+		// If it is a shared structure, we need to restore any changes after reading.
+		// Also in sequential mode, we may get incomplete reads and thus errors, and we need to restore
+		// to the state prior to an incomplete read in order to properly resume.
+		if (existingStructure && (existingStructure.isShared || sequentialMode)) {
 			(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
 		}
 		currentStructures[id] = structure;
@@ -977,10 +984,10 @@
 	currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 	currentExtensions[0].noBuffer = true;
 
-	let glbl = typeof globalThis === 'object' ? globalThis : window;
+	let errors = { Error, TypeError, ReferenceError };
 	currentExtensions[0x65] = () => {
 		let data = read();
-		return (glbl[data[0]] || Error)(data[1])
+		return (errors[data[0]] || Error)(data[1])
 	};
 
 	currentExtensions[0x69] = (data) => {
@@ -1018,6 +1025,7 @@
 
 	const typedArrays = ['Int8','Uint8','Uint8Clamped','Int16','Uint16','Int32','Uint32','Float32','Float64','BigInt64','BigUint64'].map(type => type + 'Array');
 
+	let glbl = typeof globalThis === 'object' ? globalThis : window;
 	currentExtensions[0x74] = (data) => {
 		let typeCode = data[0];
 		let typedArrayName = typedArrays[typeCode];
@@ -1314,7 +1322,7 @@
 						if (serializationsSinceTransitionRebuild < 10)
 							serializationsSinceTransitionRebuild++;
 						let sharedLength = structures.sharedLength || 0;
-						if (structures.length > sharedLength)
+						if (structures.length > sharedLength && !isSequential)
 							structures.length = sharedLength;
 						if (transitionsCount > 10000) {
 							// force a rebuild occasionally after a lot of transitions so it can get cleaned up
@@ -1522,7 +1530,7 @@
 						targetView.setFloat64(position, value);
 						position += 8;
 					}
-				} else if (type === 'object') {
+				} else if (type === 'object' || type === 'function') {
 					if (!value)
 						target[position++] = 0xc0;
 					else {
@@ -1629,6 +1637,11 @@
 							} else {
 								if (value.toJSON) // use this as an alternate mechanism for expressing how to serialize
 									return pack(value.toJSON());
+								
+								// if there is a writeFunction, use it, otherwise just encode as undefined
+								if (type === 'function')
+									return pack(this.writeFunction && this.writeFunction(value));
+								
 								// no extension found, write as object
 								writeObject(value, !value.hasOwnProperty); // if it doesn't have hasOwnProperty, don't do hasOwnProperty checks
 							}
@@ -1663,14 +1676,12 @@
 						target[position++] = 0;
 						target[position++] = 0;
 					}
-				} else if (type === 'function') {
-					pack(this.writeFunction && this.writeFunction()); // if there is a writeFunction, use it, otherwise just encode as undefined
 				} else {
 					throw new Error('Unknown type: ' + type)
 				}
 			};
 
-			const writeObject = this.useRecords === false ? this.variableMapSize ? (object) => {
+			const writePlainObject = this.variableMapSize ? (object) => {
 				// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
 				let keys = Object.keys(object);
 				let length = keys.length;
@@ -1705,7 +1716,9 @@
 				}
 				target[objectOffset++ + start] = size >> 8;
 				target[objectOffset + start] = size & 0xff;
-			} :
+			};
+
+			const writeRecord = this.useRecords === false ? writePlainObject :
 			(options.progressiveRecords && !useTwoByteRecords) ?  // this is about 2% faster for highly stable structures, since it only requires one for-in loop (but much more expensive when new structure needs to be written)
 			(object, safePrototype) => {
 				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
@@ -1777,6 +1790,14 @@
 					if (safePrototype || object.hasOwnProperty(key))
 						pack(object[key]);
 			};
+
+			// craete reference to useRecords if useRecords is a function
+			const checkUseRecords = typeof this.useRecords == 'function' && this.useRecords;
+			
+			const writeObject = checkUseRecords ? (object, safePrototype) => {
+				checkUseRecords(object) ? writeRecord(object,safePrototype) : writePlainObject(object,safePrototype);
+			} : writeRecord;
+
 			const makeRoom = (end) => {
 				let newSize;
 				if (end > 0x1000000) {
@@ -1949,7 +1970,10 @@
 		}
 	}, {
 		pack(set, allocateForWrite, pack) {
-			if (this.setAsEmptyObject) return pack({})
+			if (this.setAsEmptyObject) {
+				allocateForWrite(0);
+				return pack({})
+			}
 			let array = Array.from(set);
 			let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
 			if (this.moreTypes) {
@@ -3053,7 +3077,6 @@
 			var deserialized = packr.unpack(serialized);
 			assert.deepEqual(deserialized, data);
 		});
-
 		test('255 chars', function () {
 			const data = 'RRZG9A6I7xupPeOZhxcOcioFsuhszGOdyDUcbRf4Zef2kdPIfC9RaLO4jTM5JhuZvTsF09fbRHMGtqk7YAgu3vespeTe9l61ziZ6VrMnYu2CamK96wCkmz0VUXyqaiUoTPgzk414LS9yYrd5uh7w18ksJF5SlC2e91rukWvNqAZJjYN3jpkqHNOFchCwFrhbxq2Lrv1kSJPYCx9blRg2hGmYqTbElLTZHv20iNqwZeQbRMgSBPT6vnbCBPnOh1W';
 			var serialized = pack(data);
@@ -3152,6 +3175,44 @@
 			});
 		}
 
+		test('pack/unpack sample data with useRecords function', function () {
+			var data = [
+				{id: 1, type: 1, labels: {a: 1, b: 2}},
+				{id: 2, type: 1, labels: {b: 1, c: 2}},
+				{id: 3, type: 1, labels: {d: 1, e: 2}}
+			];
+			
+			var alternatives = [
+				{useRecords: false}, // 88 bytes
+				{useRecords: true}, // 58 bytes
+				{mapsAsObjects: true, useRecords: (v)=>!!v.id}, // 55 bytes
+				{mapsAsObjects: true, variableMapSize: true, useRecords: (v)=>!!v.id} // 49 bytes
+			];
+
+			for(let o of alternatives) {
+				let packr = new Packr(o);
+				var serialized = packr.pack(data);
+				var deserialized = packr.unpack(serialized);
+				assert.deepEqual(deserialized, data);	
+			}
+		});
+
+		test('mapAsEmptyObject combination', function () {
+			const msgpackr = new Packr({ useRecords: false, encodeUndefinedAsNil: true, variableMapSize: true, mapAsEmptyObject: true, setAsEmptyObject: true  });
+
+			const map = new Map();
+			map.set('a', 1);
+			map.set('b', 2);
+			const set = new Set();
+			set.add('a');
+			set.add('b');
+			const input = { map, set };
+
+			const packed = msgpackr.pack(input);
+			const unpacked = msgpackr.unpack(packed);
+			assert.deepEqual(unpacked.map, {});
+			assert.deepEqual(unpacked.set, {});
+		});
 		test('pack/unpack empty data with bundled strings', function () {
 			var data = {};
 			let packr = new Packr({bundleStrings: true});
@@ -3312,7 +3373,6 @@
 			assert.deepEqual(data, deserialized);
 		});
 
-
 		test('unregistered extended Array class read/write', function(){
 			var instance = new ExtendArray2();
 			instance.push(0);
@@ -3465,6 +3525,58 @@
 			assert.equal(deserialized.extendedInstance[0], 0);
 		});
 
+		test('extended class pack/unpack proxied', function(){
+			function Extended() {
+				
+			}
+			Extended.prototype.__call__ = function(){
+				return this.value * 4
+			};
+			Extended.prototype.getDouble = function() {
+				return this.value * 2
+			};
+
+			var instance = function() { instance.__call__();/* callable stuff */ };
+			Object.setPrototypeOf(instance,Extended.prototype);
+			
+			instance.value = 4;
+			var data = instance;
+
+			let packr = new Packr();
+			addExtension({
+				Class: Extended,
+				type: 15,
+				unpack: function(buffer) {
+					var e = function() { e.__call__(); };
+					Object.setPrototypeOf(e,Extended.prototype);
+					e.value = packr.unpack(buffer);
+					return e
+				},
+				pack: function(instance) {
+					return packr.pack(instance.value)
+				}
+			});
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.equal(deserialized.getDouble(), 8);
+		});
+
+		test.skip('convert Date to string', function(){
+			var data = {
+				aDate: new Date(),
+			};
+			new Packr();
+			addExtension({
+				Class: Date,
+				write(date) {
+					return date.toString()
+				}
+			});
+			var serialized = pack(data);
+			var deserialized = unpack(serialized);
+			assert.equal(deserialized.aDate, data.aDate.toString());
+		});
+
 		test('proto handling', function() {
 			var objectWithProto = JSON.parse('{"__proto__":{"foo":3}}');
 			var decoded = unpack(pack(objectWithProto));
@@ -3961,6 +4073,14 @@
 			assert.deepEqual(values, [1, 2, 3, 4]);
 		});
 
+		test('unpackMultiple with positions', () => {
+			let values = unpackMultiple(new Uint8Array([1, 2, 3, 4]));
+			assert.deepEqual(values, [1, 2, 3, 4]);
+			values = [];
+			unpackMultiple(new Uint8Array([1, 2, 3, 4]), (value,start,end) => values.push([value,start,end]));
+			assert.deepEqual(values, [[1,0,1], [2,1,2], [3,2,3], [4,3,4]]);
+		});
+
 	});
 	suite('msgpackr performance tests', function(){
 		test('performance JSON.parse', function() {