cbor-x 1.4.1 → 1.5.1

package/README.md

@@ -52,6 +52,26 @@ receivingStream.on('data', (data) => {
 ```
 The `EncoderStream` and `DecoderStream` instances  will have also the record structure extension enabled by default (see below).
 
+### Iterables
+In addition to using CBOR with streams, CBOR can also encode to an iterable that can be iterated as a sequence of binary chunks with `encodeAsIterable`, which facilitates progressive encoding:
+```JavaScript
+import { encodeAsIterable } from 'cbor-x';
+
+for (let binaryChunk of encodeAsIterable(data)){
+	// progressively get binary chunks as data is encoded
+}
+```
+And `encodeAsAsyncIterable` is also available, which returns an async iterable, and can be used to encode data from async iterables as well as Blob data.
+
+```JavaScript
+import { encodeAsAsyncIterable } from 'cbor-x';
+
+let data = { blob: new Blob(...) };
+for await (let binaryChunk of encodeAsAsyncIterable(data)){
+	// progressively get binary chunks as asynchronous data source is encoded
+}
+```
+
 ## Deno Usage
 Cbor-x modules are standard ESM modules and can be loaded directly from the [deno.land registry for cbor](https://deno.land/x/cbor) for use in Deno. The standard pack/encode and unpack/decode functionality is available on Deno, like other platforms.
 

package/decode.js

@@ -197,6 +197,7 @@ export function checkedRead() {
 			}
 			// bundled strings to skip past
 			position = bundledStrings.postBundlePosition;
+			bundledStrings = null;
 		}
 
 		if (position == srcEnd) {
@@ -360,13 +361,28 @@ export function read() {
 					return structure.read()
 				}
 				if (token < 0x10000) {
-					if (token == RECORD_INLINE_ID) // we do a special check for this so that we can keep the currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
-						return recordDefinition(read())
+					if (token == RECORD_INLINE_ID) { // we do a special check for this so that we can keep the
+						// currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
+						let length = readJustLength()
+						let id = read()
+						let structure = read()
+						recordDefinition(id, structure)
+						let object = {}
+						if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
+							let key = currentDecoder.decodeKey(structure[i - 2])
+							object[safeKey(key)] = read()
+						}
+						else for (let i = 2; i < length; i++) {
+							let key = structure[i - 2]
+							object[safeKey(key)] = read()
+						}
+						return object
+					}
 					else if (token == RECORD_DEFINITIONS_ID) {
 						let length = readJustLength()
 						let id = read()
 						for (let i = 2; i < length; i++) {
-							recordDefinition([id++, read()])
+							recordDefinition(id++, read())
 						}
 						return read()
 					} else if (token == BUNDLED_STRINGS_ID) {
@@ -874,9 +890,8 @@ currentExtensions[5] = (fraction) => {
 }
 
 // the registration of the record definition extension
-const recordDefinition = (definition) => {
-	let id = definition[0] - 0xe000
-	let structure = definition[1]
+const recordDefinition = (id, structure) => {
+	id = id - 0xe000
 	let existingStructure = currentStructures[id]
 	if (existingStructure && existingStructure.isShared) {
 		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure
@@ -884,18 +899,18 @@ const recordDefinition = (definition) => {
 	currentStructures[id] = structure
 
 	structure.read = createStructureReader(structure)
+}
+currentExtensions[LEGACY_RECORD_INLINE_ID] = (data) => {
+	let length = data.length
+	let structure = data[1]
+	recordDefinition(data[0], structure)
 	let object = {}
-	if (currentDecoder.keyMap) for (let i = 2,l = definition.length; i < l; i++) {
-			let key = currentDecoder.decodeKey(structure[i - 2])
-			object[safeKey(key)] = definition[i]
-		}
-	else for (let i = 2,l = definition.length; i < l; i++) {
-			let key = structure[i - 2]
-			object[safeKey(key)] = definition[i]
-		}
+	for (let i = 2; i < length; i++) {
+		let key = structure[i - 2]
+		object[safeKey(key)] = data[i]
+	}
 	return object
 }
-currentExtensions[LEGACY_RECORD_INLINE_ID] = recordDefinition
 currentExtensions[14] = (value) => {
 	if (bundledStrings)
 		return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.position0 += value)
@@ -933,18 +948,23 @@ currentExtensions[PACKED_REFERENCE_TAG_ID] = (data) => { // packed reference
 		return packedValues[16 + (data >= 0 ? 2 * data : (-2 * data - 1))]
 	throw new Error('No support for non-integer packed references yet')
 }
-currentExtensions[25] = (id) => {
-	return stringRefs[id]
-}
-currentExtensions[256] = (read) => {
-	stringRefs = []
-	try {
-		return read()
-	} finally {
-		stringRefs = null
-	}
-}
-currentExtensions[256].handlesRead = true
+
+// The following code is an incomplete implementation of http://cbor.schmorp.de/stringref
+// the real thing would need to implemennt more logic to populate the stringRefs table and
+// maintain a stack of stringRef "namespaces".
+//
+// currentExtensions[25] = (id) => {
+// 	return stringRefs[id]
+// }
+// currentExtensions[256] = (read) => {
+// 	stringRefs = []
+// 	try {
+// 		return read()
+// 	} finally {
+// 		stringRefs = null
+// 	}
+// }
+// currentExtensions[256].handlesRead = true
 
 currentExtensions[28] = (read) => { 
 	// shareable http://cbor.schmorp.de/value-sharing (for structured clones)