cbor-x 1.3.3 → 1.4.1

package/index.d.ts

@@ -1,12 +1,61 @@
-import { Options } from './decode'
-export { Decoder, decode, addExtension, FLOAT32_OPTIONS, clearSource, roundFloat32, isNativeAccelerationEnabled } from './decode'
-export { Encoder, encode } from './encode'
-import { Transform, Readable } from 'stream'
-
-export as namespace CBOR;
-export class DecoderStream extends Transform {
-	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
-}
-export class EncoderStream extends Transform {
-	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
-}
+export enum FLOAT32_OPTIONS {
+	NEVER = 0,
+	ALWAYS = 1,
+	DECIMAL_ROUND = 3,
+	DECIMAL_FIT = 4
+}
+
+export interface Options {
+	useFloat32?: FLOAT32_OPTIONS
+	useRecords?: boolean
+	structures?: {}[]
+	structuredClone?: boolean
+	mapsAsObjects?: boolean
+	variableMapSize?: boolean
+	copyBuffers?: boolean
+	bundleStrings?: boolean
+	useTimestamp32?: boolean
+	largeBigIntToFloat?: boolean
+	encodeUndefinedAsNil?: boolean
+	maxSharedStructures?: number
+	maxOwnStructures?: number
+	useSelfDescribedHeader?: boolean
+	keyMap?: {}
+	shouldShareStructure?: (keys: string[]) => boolean
+	getStructures?(): {}[]
+	saveStructures?(structures: {}[]): boolean | void
+	onInvalidDate?: () => any
+	tagUint8Array?: boolean
+}
+interface Extension {
+	Class: Function
+	tag: number
+	encode(value: any): Buffer | Uint8Array
+	decode(messagePack: Buffer | Uint8Array): any
+}
+export class Decoder {
+	constructor(options?: Options)
+	decode(messagePack: Buffer | Uint8Array): any
+	decodeMultiple(messagePack: Buffer | Uint8Array, forEach?: (value: any) => any): [] | void
+}
+export function decode(messagePack: Buffer | Uint8Array): any
+export function decodeMultiple(messagePack: Buffer | Uint8Array, forEach?: (value: any) => any): [] | void
+export function addExtension(extension: Extension): void
+export function clearSource(): void
+export function roundFloat32(float32Number: number): number
+export let isNativeAccelerationEnabled: boolean
+
+export class Encoder extends Decoder {
+	encode(value: any): Buffer
+}
+export function encode(value: any): Buffer
+
+import { Transform, Readable } from 'stream'
+
+export as namespace CBOR;
+export class DecoderStream extends Transform {
+	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
+}
+export class EncoderStream extends Transform {
+	constructor(options?: Options | { highWaterMark: number, emitClose: boolean, allowHalfOpen: boolean })
+}

package/index.js

@@ -1,3 +1,3 @@
-export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT, REUSE_BUFFER_MODE } from './encode.js'
-export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32, isNativeAccelerationEnabled } from './decode.js'
-export { decodeIter, encodeIter } from './iterators.js'
+export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT, REUSE_BUFFER_MODE } from './encode.js'
+export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32, isNativeAccelerationEnabled } from './decode.js'
+export { decodeIter, encodeIter } from './iterators.js'

package/iterators.js

@@ -1,85 +1,85 @@
-import { Encoder } from './encode.js'
-import { Decoder } from './decode.js'
-
-/**
- * Given an Iterable first argument, returns an Iterable where each value is encoded as a Buffer
- * If the argument is only Async Iterable, the return value will be an Async Iterable.
- * @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
- * @param {options} [options] - cbor-x Encoder options
- * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
- */
-export function encodeIter (objectIterator, options = {}) {
-  if (!objectIterator || typeof objectIterator !== 'object') {
-    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
-  } else if (typeof objectIterator[Symbol.iterator] === 'function') {
-    return encodeIterSync(objectIterator, options)
-  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
-    return encodeIterAsync(objectIterator, options)
-  } else {
-    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
-  }
-}
-
-function * encodeIterSync (objectIterator, options) {
-  const encoder = new Encoder(options)
-  for (const value of objectIterator) {
-    yield encoder.encode(value)
-  }
-}
-
-async function * encodeIterAsync (objectIterator, options) {
-  const encoder = new Encoder(options)
-  for await (const value of objectIterator) {
-    yield encoder.encode(value)
-  }
-}
-
-/**
- * Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
- * Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
- * @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
- * @param {object} [options] - Decoder options
- * @returns {IterableIterator|Promise.<AsyncIterableIterator}
- */
-export function decodeIter (bufferIterator, options = {}) {
-  if (!bufferIterator || typeof bufferIterator !== 'object') {
-    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
-  }
-
-  const decoder = new Decoder(options)
-  let incomplete
-  const parser = (chunk) => {
-    let yields
-    // if there's incomplete data from previous chunk, concatinate and try again
-    if (incomplete) {
-      chunk = Buffer.concat([incomplete, chunk])
-      incomplete = undefined
-    }
-
-    try {
-      yields = decoder.decodeMultiple(chunk)
-    } catch (err) {
-      if (err.incomplete) {
-        incomplete = chunk.slice(err.lastPosition)
-        yields = err.values
-      } else {
-        throw err
-      }
-    }
-    return yields
-  }
-
-  if (typeof bufferIterator[Symbol.iterator] === 'function') {
-    return (function * iter () {
-      for (const value of bufferIterator) {
-        yield * parser(value)
-      }
-    })()
-  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
-    return (async function * iter () {
-      for await (const value of bufferIterator) {
-        yield * parser(value)
-      }
-    })()
-  }
-}
+import { Encoder } from './encode.js'
+import { Decoder } from './decode.js'
+
+/**
+ * Given an Iterable first argument, returns an Iterable where each value is encoded as a Buffer
+ * If the argument is only Async Iterable, the return value will be an Async Iterable.
+ * @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
+ * @param {options} [options] - cbor-x Encoder options
+ * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
+ */
+export function encodeIter (objectIterator, options = {}) {
+  if (!objectIterator || typeof objectIterator !== 'object') {
+    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
+  } else if (typeof objectIterator[Symbol.iterator] === 'function') {
+    return encodeIterSync(objectIterator, options)
+  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
+    return encodeIterAsync(objectIterator, options)
+  } else {
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
+  }
+}
+
+function * encodeIterSync (objectIterator, options) {
+  const encoder = new Encoder(options)
+  for (const value of objectIterator) {
+    yield encoder.encode(value)
+  }
+}
+
+async function * encodeIterAsync (objectIterator, options) {
+  const encoder = new Encoder(options)
+  for await (const value of objectIterator) {
+    yield encoder.encode(value)
+  }
+}
+
+/**
+ * Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
+ * Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
+ * @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
+ * @param {object} [options] - Decoder options
+ * @returns {IterableIterator|Promise.<AsyncIterableIterator}
+ */
+export function decodeIter (bufferIterator, options = {}) {
+  if (!bufferIterator || typeof bufferIterator !== 'object') {
+    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
+  }
+
+  const decoder = new Decoder(options)
+  let incomplete
+  const parser = (chunk) => {
+    let yields
+    // if there's incomplete data from previous chunk, concatinate and try again
+    if (incomplete) {
+      chunk = Buffer.concat([incomplete, chunk])
+      incomplete = undefined
+    }
+
+    try {
+      yields = decoder.decodeMultiple(chunk)
+    } catch (err) {
+      if (err.incomplete) {
+        incomplete = chunk.slice(err.lastPosition)
+        yields = err.values
+      } else {
+        throw err
+      }
+    }
+    return yields
+  }
+
+  if (typeof bufferIterator[Symbol.iterator] === 'function') {
+    return (function * iter () {
+      for (const value of bufferIterator) {
+        yield * parser(value)
+      }
+    })()
+  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
+    return (async function * iter () {
+      for await (const value of bufferIterator) {
+        yield * parser(value)
+      }
+    })()
+  }
+}

package/node-index.js

@@ -1,24 +1,24 @@
-export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT, REUSE_BUFFER_MODE } from './encode.js'
-export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32, isNativeAccelerationEnabled } from './decode.js'
-export { EncoderStream, DecoderStream } from './stream.js'
-export { decodeIter, encodeIter } from './iterators.js'
-export const useRecords = false
-export const mapsAsObjects = true
-import { setExtractor } from './decode.js'
-import { createRequire } from 'module'
-
-const nativeAccelerationDisabled = process.env.CBOR_NATIVE_ACCELERATION_DISABLED !== undefined && process.env.CBOR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === 'true';
-
-if (!nativeAccelerationDisabled) {
-	let extractor
-	try {
-		if (typeof require == 'function')
-			extractor = require('cbor-extract')
-		else
-			extractor = createRequire(import.meta.url)('cbor-extract')
-		if (extractor)
-			setExtractor(extractor.extractStrings)
-	} catch (error) {
-		// native module is optional
-	}
-}
+export { Encoder, addExtension, encode, NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT, REUSE_BUFFER_MODE } from './encode.js'
+export { Tag, Decoder, decodeMultiple, decode, FLOAT32_OPTIONS, clearSource, roundFloat32, isNativeAccelerationEnabled } from './decode.js'
+export { EncoderStream, DecoderStream } from './stream.js'
+export { decodeIter, encodeIter } from './iterators.js'
+export const useRecords = false
+export const mapsAsObjects = true
+import { setExtractor } from './decode.js'
+import { createRequire } from 'module'
+
+const nativeAccelerationDisabled = process.env.CBOR_NATIVE_ACCELERATION_DISABLED !== undefined && process.env.CBOR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === 'true';
+
+if (!nativeAccelerationDisabled) {
+	let extractor
+	try {
+		if (typeof require == 'function')
+			extractor = require('cbor-extract')
+		else
+			extractor = createRequire(import.meta.url)('cbor-extract')
+		if (extractor)
+			setExtractor(extractor.extractStrings)
+	} catch (error) {
+		// native module is optional
+	}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cbor-x",
   "author": "Kris Zyp",
-  "version": "1.3.3",
+  "version": "1.4.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",
@@ -31,6 +31,10 @@
         "require": "./dist/node.cjs",
         "import": "./node-index.js"
       },
+      "types": {
+        "require": "./index.d.cts",
+        "import": "./index.d.ts"
+      },
       "default": "./index.js"
     },
     "./encode": {
@@ -69,6 +73,7 @@
     "cbor": "^5",
     "cbor-sync": "^1.0.4",
     "chai": "^4.3.4",
+    "cpy-cli": "^4.1.0",
     "esm": "^3.2.25",
     "mocha": "^8.1.3",
     "rollup": "^1.20.3",

package/rollup.config.js

@@ -1,45 +1,45 @@
-import minify from "rollup-plugin-babel-minify";
-import json  from "@rollup/plugin-json";
-
-export default [
-    {
-        input: "node-index.js",
-        output: [
-            {
-                file: "dist/node.cjs",
-                format: "cjs"
-            }
-        ]
-    },
-    {
-        input: "index.js",
-        output: {
-            file: "dist/index.js",
-            format: "umd",
-            name: "CBOR"
-        }
-    },    
-    {
-        input: "index.js",
-        plugins: [minify({
-        })],
-        output: {
-            file: "dist/index.min.js",
-            format: "umd",
-            name: "CBOR"
-        }
-    },
-    {
-        input: "tests/test.js",
-        plugins: [json()],
-        external: ['chai', '../index.js'],
-        output: {
-            file: "dist/test.js",
-            format: "iife",
-            globals: {
-                chai: 'chai',
-                './index.js': 'CBOR',
-            },
-        }
-    }
-];
+import minify from "rollup-plugin-babel-minify";
+import json  from "@rollup/plugin-json";
+
+export default [
+    {
+        input: "node-index.js",
+        output: [
+            {
+                file: "dist/node.cjs",
+                format: "cjs"
+            }
+        ]
+    },
+    {
+        input: "index.js",
+        output: {
+            file: "dist/index.js",
+            format: "umd",
+            name: "CBOR"
+        }
+    },    
+    {
+        input: "index.js",
+        plugins: [minify({
+        })],
+        output: {
+            file: "dist/index.min.js",
+            format: "umd",
+            name: "CBOR"
+        }
+    },
+    {
+        input: "tests/test.js",
+        plugins: [json()],
+        external: ['chai', '../index.js'],
+        output: {
+            file: "dist/test.js",
+            format: "iife",
+            globals: {
+                chai: 'chai',
+                './index.js': 'CBOR',
+            },
+        }
+    }
+];

package/stream.js

@@ -1,57 +1,57 @@
-import { Transform } from 'stream'
-import { Encoder } from './encode.js'
-import { checkedRead, getPosition, Decoder, clearSource } from './decode.js'
-var DEFAULT_OPTIONS = {objectMode: true}
-
-export class EncoderStream extends Transform {
-	constructor(options) {
-		if (!options)
-			options = {}
-		options.writableObjectMode = true
-		super(options)
-		options.sequential = true
-		this.encoder = options.encoder || new Encoder(options)
-	}
-	_transform(value, encoding, callback) {
-		this.push(this.encoder.encode(value))
-		callback()
-	}
-}
-
-export class DecoderStream extends Transform {
-	constructor(options) {
-		if (!options)
-			options = {}
-		options.objectMode = true
-		super(options)
-		options.structures = []
-		this.decoder = options.decoder || new Decoder(options)
-	}
-	_transform(chunk, encoding, callback) {
-		if (this.incompleteBuffer) {
-			chunk = Buffer.concat([this.incompleteBuffer, chunk])
-			this.incompleteBuffer = null
-		}
-		let values
-		try {
-			values = this.decoder.decodeMultiple(chunk)
-		} catch(error) {
-			if (error.incomplete) {
-				this.incompleteBuffer = chunk.slice(error.lastPosition)
-				values = error.values
-			}
-			else
-				throw error
-		} finally {
-			for (let value of values || []) {
-				if (value === null)
-					value = this.getNullValue()
-				this.push(value)
-			}
-		}
-		if (callback) callback()
-	}
-	getNullValue() {
-		return Symbol.for(null)
-	}
-}
+import { Transform } from 'stream'
+import { Encoder } from './encode.js'
+import { checkedRead, getPosition, Decoder, clearSource } from './decode.js'
+var DEFAULT_OPTIONS = {objectMode: true}
+
+export class EncoderStream extends Transform {
+	constructor(options) {
+		if (!options)
+			options = {}
+		options.writableObjectMode = true
+		super(options)
+		options.sequential = true
+		this.encoder = options.encoder || new Encoder(options)
+	}
+	_transform(value, encoding, callback) {
+		this.push(this.encoder.encode(value))
+		callback()
+	}
+}
+
+export class DecoderStream extends Transform {
+	constructor(options) {
+		if (!options)
+			options = {}
+		options.objectMode = true
+		super(options)
+		options.structures = []
+		this.decoder = options.decoder || new Decoder(options)
+	}
+	_transform(chunk, encoding, callback) {
+		if (this.incompleteBuffer) {
+			chunk = Buffer.concat([this.incompleteBuffer, chunk])
+			this.incompleteBuffer = null
+		}
+		let values
+		try {
+			values = this.decoder.decodeMultiple(chunk)
+		} catch(error) {
+			if (error.incomplete) {
+				this.incompleteBuffer = chunk.slice(error.lastPosition)
+				values = error.values
+			}
+			else
+				throw error
+		} finally {
+			for (let value of values || []) {
+				if (value === null)
+					value = this.getNullValue()
+				this.push(value)
+			}
+		}
+		if (callback) callback()
+	}
+	getNullValue() {
+		return Symbol.for(null)
+	}
+}

package/webpack.config.js

@@ -1,19 +1,19 @@
-var webpack = require('webpack')
-var path = require('path')
-module.exports = {
-    entry: {
-        index: './browser.js'
-    },
-    output: {
-        path: path.join(__dirname, 'dist'),
-        library: 'CBOR',
-        libraryTarget: 'umd'
-    },
-    node: { Buffer: false },
-    devtool: 'source-map',
-    optimization: {
-        minimize: true
-    },
-    //mode: 'development'
-    mode: 'production'
-};
+var webpack = require('webpack')
+var path = require('path')
+module.exports = {
+    entry: {
+        index: './browser.js'
+    },
+    output: {
+        path: path.join(__dirname, 'dist'),
+        library: 'CBOR',
+        libraryTarget: 'umd'
+    },
+    node: { Buffer: false },
+    devtool: 'source-map',
+    optimization: {
+        minimize: true
+    },
+    //mode: 'development'
+    mode: 'production'
+};