msgpackr 2.0.0 → 2.0.1

package/dist/node.cjs

@@ -96,7 +96,7 @@ class Unpackr {
 			currentUnpackr = this;
 			if (this.structures) {
 				currentStructures = this.structures;
-				return checkedRead();
+				return checkedRead(options);
 			} else if (!currentStructures || currentStructures.length > 0) {
 				currentStructures = [];
 			}
@@ -105,7 +105,7 @@ class Unpackr {
 			if (!currentStructures || currentStructures.length > 0)
 				currentStructures = [];
 		}
-		return checkedRead();
+		return checkedRead(options);
 	}
 	unpackMultiple(source, forEach) {
 		let values, lastPosition = 0;
@@ -140,6 +140,8 @@ class Unpackr {
 		}
 	}
 	_mergeStructures(loadedStructures, existingStructures) {
+		if (this._onLoadedStructures)
+			loadedStructures = this._onLoadedStructures(loadedStructures);
 		loadedStructures = loadedStructures || [];
 		if (Object.isFrozen(loadedStructures))
 			loadedStructures = loadedStructures.map(structure => structure.slice(0));
@@ -176,7 +178,15 @@ function checkedRead(options) {
 			if (sharedLength < currentStructures.length)
 				currentStructures.length = sharedLength;
 		}
-		let result = read();
+		let result;
+		if (currentUnpackr._readStruct && src[position$1] < 0x40 && src[position$1] >= 0x20) {
+			result = currentUnpackr._readStruct(src, position$1, srcEnd);
+			src = null; // dispose of this so that recursive unpack calls don't save state
+			if (!(options && options.lazy) && result)
+				result = result.toJSON();
+			position$1 = srcEnd;
+		} else
+			result = read();
 		if (bundledStrings$1) { // bundled strings to skip past
 			position$1 = bundledStrings$1.postBundlePosition;
 			bundledStrings$1 = null;
@@ -1141,6 +1151,8 @@ currentExtensions[0xff] = (data) => {
 // currentExtensions[0x52] = () =>
 
 function saveState(callback) {
+	if (currentUnpackr && currentUnpackr._onSaveState)
+		currentUnpackr._onSaveState();
 	let savedSrcEnd = srcEnd;
 	let savedPosition = position$1;
 	let savedStringPosition = stringPosition;
@@ -1210,6 +1222,10 @@ function roundFloat32(float32Number) {
 	let multiplier = mult10[((u8Array[3] & 0x7f) << 1) | (u8Array[2] >> 7)];
 	return ((multiplier * float32Number + (float32Number > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
 }
+// Marker for downstream libraries (e.g. structon) to detect per-instance
+// struct-decoding hooks (this._readStruct, this._onLoadedStructures,
+// this._onSaveState).  See `checkedRead` for the dispatch.
+Unpackr.SUPPORTS_STRUCT_HOOKS = true;
 
 let textEncoder;
 try {
@@ -1333,7 +1349,14 @@ class Packr extends Unpackr {
 				hasSharedUpdate = false;
 			let encodingError;
 			try {
-				pack(value);
+				if (packr._writeStruct && value && typeof value === 'object') {
+					if (value.constructor === Object) writeStruct(value); // simple object
+					else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some(extClass => value instanceof extClass)) {
+						// allow user classes, if they don't need special handling (but do use toJSON if available)
+						writeStruct(value.toJSON ? value.toJSON() : value);
+					} else pack(value);
+				} else
+					pack(value);
 				let lastBundle = bundledStrings;
 				if (bundledStrings)
 					writeBundles(start, pack, 0);
@@ -1389,7 +1412,7 @@ class Packr extends Unpackr {
 						let sharedLength = structures.sharedLength || 0;
 						// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
 						let returnBuffer = target.subarray(start, position);
-						let newSharedData = prepareStructures(structures, packr);
+						let newSharedData = (packr._prepareStructures || prepareStructures)(structures, packr);
 						if (!encodingError) { // TODO: If there is an encoding error, should make the structures as uninitialized so they get rebuilt next time
 							if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
 								// get updated structures and try again if the update failed
@@ -1558,7 +1581,7 @@ class Packr extends Unpackr {
 			} else if (type === 'number') {
 				if (value >>> 0 === value) {// positive integer, 32-bit or less
 					// positive uint
-					if (value < 0x40 || (value < 0x80 && this.useRecords === false)) {
+					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this._writeStruct)) {
 						target[position++] = value;
 					} else if (value < 0x100) {
 						target[position++] = 0xcc;
@@ -1949,6 +1972,24 @@ class Packr extends Unpackr {
 			checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
 		} : writeRecord;
 
+		const writeStruct = (object) => {
+			let newPosition = packr._writeStruct(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
+				if (notifySharedUpdate)
+					return hasSharedUpdate = true;
+				position = newPosition;
+				let startTarget = target;
+				pack(value);
+				resetStructures();
+				if (startTarget !== target) {
+					return { position, targetView, target }; // indicate the buffer was re-allocated
+				}
+				return position;
+			});
+			if (newPosition === 0) // bail and go to a msgpack object
+				return writeObject(object);
+			position = newPosition;
+		};
+
 		const makeRoom = (end) => {
 			let newSize;
 			if (end > 0x1000000) {
@@ -2068,6 +2109,8 @@ class Packr extends Unpackr {
 	clearSharedData() {
 		if (this.structures)
 			this.structures = [];
+		if (this.typedStructs)
+			this.typedStructs = [];
 	}
 }
 
@@ -2309,6 +2352,11 @@ function prepareStructures(structures, packr) {
 	return structures;
 }
 
+// Marker for downstream libraries (e.g. structon) to detect that this Packr
+// supports per-instance struct-encoding hooks (this._writeStruct,
+// this._prepareStructures).  See `pack` for the dispatch.
+Packr.SUPPORTS_STRUCT_HOOKS = true;
+
 let defaultPackr = new Packr({ useRecords: false });
 const pack = defaultPackr.pack;
 const encode = defaultPackr.pack;