msgpackr 1.9.2 → 1.9.4

package/README.md

@@ -172,7 +172,7 @@ unpackMultiple(data, (value,start,end) => {
 ## Options
 The following options properties can be provided to the Packr or Unpackr constructor:
 
-* `useRecords` - Setting this to `false` disables the record extension and stores JavaScript objects as MessagePack maps, and unpacks maps as JavaScript `Object`s, which ensures compatibilty with other decoders.
+* `useRecords` - Setting this to `false` disables the record extension and stores JavaScript objects as MessagePack maps, and unpacks maps as JavaScript `Object`s, which ensures compatibilty with other decoders. Setting this to a function will use records for objects where `useRecords(object)` returns `true`.
 * `structures` - Provides the array of structures that is to be used for record extension, if you want the structures saved and used again. This array will be modified in place with new record structures that are serialized (if less than 32 structures are in the array).
 * `moreTypes` - Enable serialization of additional built-in types/classes including typed arrays, `Set`s, `Map`s, and `Error`s.
 * `structuredClone` - This enables the structured cloning extensions that will encode object/cyclic references. `moreTypes` is enabled by default when this is enabled.

package/dist/index-no-eval.cjs

@@ -933,10 +933,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) => {
@@ -974,6 +974,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];
@@ -1468,7 +1469,7 @@
 						targetView.setFloat64(position, value);
 						position += 8;
 					}
-				} else if (type === 'object') {
+				} else if (type === 'object' || type === 'function') {
 					if (!value)
 						target[position++] = 0xc0;
 					else {
@@ -1575,6 +1576,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
 							}
@@ -1609,14 +1615,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 || this.coercibleKeyAsNumber) ? (object) => {
 				// this method is slightly slower, but generates "preferred serialization" (optimally small for smaller objects)
 				let keys = Object.keys(object);
 				let length = keys.length;
@@ -1632,9 +1636,19 @@
 					position += 4;
 				}
 				let key;
-				for (let i = 0; i < length; i++) {
-					pack(key = keys[i]);
-					pack(object[key]);
+				if (this.coercibleKeyAsNumber) {
+					for (let i = 0; i < length; i++) {
+						key = keys[i];
+						let num = Number(key);
+						pack(isNaN(num) ? key : num);
+						pack(object[key]);
+					}
+
+				} else {
+					for (let i = 0; i < length; i++) {
+						pack(key = keys[i]);
+						pack(object[key]);
+					}
 				}
 			} :
 			(object, safePrototype) => {
@@ -1651,7 +1665,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));
@@ -1723,6 +1739,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) {