cbor-x 1.0.0 → 1.2.1

package/encode.js

@@ -38,12 +38,18 @@ export class Encoder extends Decoder {
 			} : false
 
 		let encoder = this
-		let maxSharedStructures = options.maxSharedStructures || 128
+		let hasSharedStructures = options.structures || options.saveStructures
+		let maxSharedStructures = options.maxSharedStructures
+		if (maxSharedStructures == null)
+			maxSharedStructures = hasSharedStructures ? 128 : 0
+		if (maxSharedStructures > 8190)
+			throw new Error('Maximum maxSharedStructure is 8190')
 		let isSequential = options.sequential
 		if (isSequential) {
 			maxSharedStructures = 0
-			this.structures = []
 		}
+		if (!this.structures)
+			this.structures = []
 		if (this.saveStructures)
 			this.saveShared = this.saveStructures
 		let samplingPackedValues, packedObjectMap, sharedValues = options.sharedValues
@@ -91,6 +97,10 @@ export class Encoder extends Decoder {
 			} else if (encodeOptions === REUSE_BUFFER_MODE)
 				position = (position + 7) & 0x7ffffff8 // Word align to make any future copying of this buffer faster
 			start = position
+			if (encoder.useSelfDescribedHeader) {
+				targetView.setUint32(position, 0xd9d9f700) // tag two byte, then self-descriptive tag
+				position += 3
+			}
 			referenceMap = encoder.structuredClone ? new Map() : null
 			if (encoder.bundleStrings && typeof value !== 'string') {
 				bundledStrings = []
@@ -124,6 +134,8 @@ export class Encoder extends Decoder {
 							continue
 						let nextTransition, transition = sharedStructures.transitions
 						for (let j = 0, l = keys.length; j < l; j++) {
+							if (transition[RECORD_SYMBOL] === undefined)
+								transition[RECORD_SYMBOL] = i
 							let key = keys[j]
 							nextTransition = transition[key]
 							if (!nextTransition) {
@@ -131,7 +143,7 @@ export class Encoder extends Decoder {
 							}
 							transition = nextTransition
 						}
-						transition[RECORD_SYMBOL] = i
+						transition[RECORD_SYMBOL] = i | 0x100000
 					}
 				}
 				if (!isSequential)
@@ -183,11 +195,13 @@ export class Encoder extends Decoder {
 					target.end = position
 					return target
 				}
-				return target.subarray(start, position) // position can change if we call pack again in saveShared, so we get the buffer now
+				return target.subarray(start, position) // position can change if we call encode again in saveShared, so we get the buffer now
 			} finally {
 				if (sharedStructures) {
 					if (serializationsSinceTransitionRebuild < 10)
 						serializationsSinceTransitionRebuild++
+					if (sharedStructures.length > maxSharedStructures)
+						sharedStructures.length = maxSharedStructures
 					if (transitionsCount > 10000) {
 						// force a rebuild occasionally after a lot of transitions so it can get cleaned up
 						sharedStructures.transitions = null
@@ -200,6 +214,7 @@ export class Encoder extends Decoder {
 							recordIdsToRemove[i][RECORD_SYMBOL] = undefined
 						}
 						recordIdsToRemove = []
+						//sharedStructures.nextId = maxSharedStructures
 					}
 				}
 				if (hasSharedUpdate && encoder.saveShared) {
@@ -499,7 +514,9 @@ export class Encoder extends Decoder {
 							let extensionClass = extensionClasses[i]
 							if (value instanceof extensionClass) {
 								let extension = extensions[i]
-								let tag = extension.tag || extension.getTag && extension.getTag(value)
+								let tag = extension.tag
+								if (tag == undefined)
+									tag = extension.getTag && extension.getTag(value)
 								if (tag < 0x18) {
 									target[position++] = 0xc0 | tag
 								} else if (tag < 0x100) {
@@ -611,88 +628,74 @@ export class Encoder extends Decoder {
 			target[objectOffset++ + start] = size >> 8
 			target[objectOffset + start] = size & 0xff
 		} :
-
-	/*	sharedStructures ?  // For highly stable structures, using for-in can a little bit faster
 		(object, safePrototype) => {
 			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let objectOffset = position++ - start
-			let wroteKeys
-			for (let key in object) {
-				if (safePrototype || object.hasOwnProperty(key)) {
+			let newTransitions = 0
+			let length = 0
+			let parentRecordId
+			let keys
+			if (this.keyMap) {
+				keys = Object.keys(object).map(k => this.encodeKey(k))
+				length = keys.length
+				for (let i = 0; i < length; i++) {
+					let key = keys[i]
 					nextTransition = transition[key]
 					if (!nextTransition) {
 						nextTransition = transition[key] = Object.create(null)
-						nextTransition.__keys__ = (transition.__keys__ || []).concat([key])
-						/*let keys = Object.keys(object)
-						if 
-						let size = 0
-						let startBranch = transition.__keys__ ? transition.__keys__.length : 0
-						for (let i = 0, l = keys.length; i++) {
-							let key = keys[i]
-							size += key.length << 2
-							if (i >= startBranch) {
-								nextTransition = nextTransition[key] = Object.create(null)
-								nextTransition.__keys__ = keys.slice(0, i + 1)
-							}
+						newTransitions++
+					}
+					transition = nextTransition
+				}				
+			} else {
+				for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
+					nextTransition = transition[key]
+					if (!nextTransition) {
+						if (transition[RECORD_SYMBOL] & 0x100000) {// this indicates it is a brancheable/extendable terminal node, so we will use this record id and extend it
+							parentRecordId = transition[RECORD_SYMBOL] & 0xffff
 						}
-						makeRoom(position + size)
-						nextTransition = transition[key]
-						target.copy(target, )
-						objectOffset
+						nextTransition = transition[key] = Object.create(null)
+						newTransitions++
 					}
 					transition = nextTransition
-					encode(object[key])
-				}
-			}
-			let id = transition.id
-			if (!id) {
-				id = transition.id = structures.push(transition.__keys__) + 63
-				if (sharedStructures.onUpdate)
-					sharedStructures.onUpdate(id, transition.__keys__)
-			}
-			target[objectOffset + start] = id
-		}*/
-		(object) => {
-			let keys = Object.keys(object)
-			let vals = Object.values(object)
-			if (this.keyMap) keys = keys.map(k => this.encodeKey(k))
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let newTransitions = 0
-			let length = keys.length
-			//let parentRecordId
-			for (let i = 0; i < length; i++) {
-				//if (!parentRecordId)
-				let key = keys[i]
-				//	parentRecordId = transition[RECORD_SYMBOL]
-				nextTransition = transition[key]
-				if (!nextTransition) {
-					nextTransition = transition[key] = Object.create(null)
-					newTransitions++
+					length++
 				}
-				transition = nextTransition
 			}
 			let recordId = transition[RECORD_SYMBOL]
 			if (recordId !== undefined) {
+				recordId &= 0xffff
 				target[position++] = 0xd9
 				target[position++] = (recordId >> 8) | 0xe0
 				target[position++] = recordId & 0xff
 			} else {
-				recordId = structures.nextId++
-				if (!recordId) {
-					recordId = 0
-					structures.nextId = 1
-				}
-				if (recordId >= MAX_STRUCTURES) {// cycle back around
-					structures.nextId = (recordId = maxSharedStructures) + 1
+				if (!keys)
+					keys = transition.__keys__ || (transition.__keys__ = Object.keys(object))
+				if (parentRecordId === undefined) {
+					recordId = structures.nextId++
+					if (!recordId) {
+						recordId = 0
+						structures.nextId = 1
+					}
+					if (recordId >= MAX_STRUCTURES) {// cycle back around
+						structures.nextId = (recordId = maxSharedStructures) + 1
+					}
+				} else {
+					recordId = parentRecordId
 				}
-				transition[RECORD_SYMBOL] = recordId
 				structures[recordId] = keys
-				if (sharedStructures && sharedStructures.length <= maxSharedStructures) {
+				if (recordId < maxSharedStructures) {
 					target[position++] = 0xd9
 					target[position++] = (recordId >> 8) | 0xe0
 					target[position++] = recordId & 0xff
+					transition = structures.transitions
+					for (let i = 0; i < length; i++) {
+						if (transition[RECORD_SYMBOL] === undefined || (transition[RECORD_SYMBOL] & 0x100000))
+							transition[RECORD_SYMBOL] = recordId
+						transition = transition[keys[i]]
+					}
+					transition[RECORD_SYMBOL] = recordId | 0x100000 // indicates it is a extendable terminal
 					hasSharedUpdate = true
 				} else {
+					transition[RECORD_SYMBOL] = recordId
 					targetView.setUint32(position, 0xd9dfff00) // tag two byte, then record definition id
 					position += 3
 					if (newTransitions)
@@ -713,7 +716,9 @@ export class Encoder extends Decoder {
 			} else {
 				writeArrayHeader(length)
 			}
-			for (let i =0; i < length; i++) encode(vals[i])
+			for (let key in object)
+				if (safePrototype || object.hasOwnProperty(key))
+					encode(object[key])
 		}
 		const makeRoom = (end) => {
 			let newSize
@@ -752,15 +757,22 @@ export class Encoder extends Decoder {
 	updateSharedData() {
 		let lastVersion = this.sharedVersion || 0
 		this.sharedVersion = lastVersion + 1
-		let saveResults = this.saveShared(new SharedData(this.structures, this.sharedValues, this.sharedVersion),
+		let structuresCopy = this.structures.slice(0)
+		let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion)
+		let saveResults = this.saveShared(sharedData,
 				existingShared => (existingShared && existingShared.version || 0) == lastVersion)
 		if (saveResults === false) {
 			// get updated structures and try again if the update failed
-			let sharedData = this.getShared() || {}
+			sharedData = this.getShared() || {}
 			this.structures = sharedData.structures || []
 			this.sharedValues = sharedData.packedValues
 			this.sharedVersion = sharedData.version
+			this.structures.nextId = this.structures.length
+		} else {
+			// restore structures
+			structuresCopy.forEach((structure, i) => this.structures[i] = structure)
 		}
+		// saveShared may fail to write and reload, or may have reloaded to check compatibility and overwrite saved data, either way load the correct shared data
 		return saveResults
 	}
 }
@@ -838,7 +850,7 @@ function findRepetitiveStrings(value, packedValues) {
 		case 'function': console.log(value)
 	}
 }
-
+const isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1
 extensionClasses = [ Date, Set, Error, RegExp, Tag, ArrayBuffer, ByteArray,
 	Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array,
 	typeof BigUint64Array == 'undefined' ? function() {} : BigUint64Array, Int8Array, Int16Array, Int32Array,
@@ -893,17 +905,17 @@ extensions = [{
 	encode(arrayBuffer, encode, makeRoom) {
 		writeBuffer(arrayBuffer, makeRoom)
 	}
-}, typedArrayEncoder(64),
-	typedArrayEncoder(68),
-	typedArrayEncoder(69),
-	typedArrayEncoder(70),
-	typedArrayEncoder(71),
-	typedArrayEncoder(72),
-	typedArrayEncoder(77),
-	typedArrayEncoder(78),
-	typedArrayEncoder(79),
-	typedArrayEncoder(81),
-	typedArrayEncoder(82),
+}, typedArrayEncoder(64, 1),
+	typedArrayEncoder(68, 1),
+	typedArrayEncoder(69, 2),
+	typedArrayEncoder(70, 4),
+	typedArrayEncoder(71, 8),
+	typedArrayEncoder(72, 1),
+	typedArrayEncoder(77, 2),
+	typedArrayEncoder(78, 4),
+	typedArrayEncoder(79, 8),
+	typedArrayEncoder(85, 4),
+	typedArrayEncoder(86, 8),
 {
 	encode(sharedData, encode) { // write SharedData
 		let packedValues = sharedData.packedValues || []
@@ -932,8 +944,9 @@ extensions = [{
 			encode(new Tag(sharedData.version, 0x53687264))
 		}
 	}]
-
-function typedArrayEncoder(tag) {
+function typedArrayEncoder(tag, size) {
+	if (!isLittleEndianMachine && size > 1)
+		tag -= 4 // the big endian equivalents are 4 less
 	return {
 		tag: tag,
 		encode: function writeExtBuffer(typedArray, encode) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cbor-x",
   "author": "Kris Zyp",
-  "version": "1.0.0",
+  "version": "1.2.1",
   "description": "Ultra-fast and conformant CBOR (RFC 8949) implementation with support for numerous tag extensions including records and structured cloning",
   "license": "MIT",
   "types": "./index.d.ts",