ordered-binary 1.2.0 → 1.2.4

package/README.md

@@ -32,3 +32,8 @@ The main module exports these functions:
 `toBufferKey(jsPrimitive)` - This accepts a string, number, or boolean as the argument, and returns a `Buffer`.
 
 `fromBufferKey(bufferKey, multiple)` - This accepts a Buffer and returns a JavaScript primitive value. This can also parse buffers that hold multiple values delimited by a byte `30`, by setting the second argument to true (in which case it will return an array).
+
+And these constants:
+
+`MINIMUM_KEY` - The minimum key supported (`null`, which is represented as single zero byte)
+`MAXIMUM_KEY` - A maximum key larger than any supported primitive (single 0xff byte)

package/dist/index.cjs

@@ -66,10 +66,13 @@ function writeKey(key, target, position, inSequence) {
 					target[position++] = c1 & 0x3f | 0x80;
 				}
 			}
-		} else if (target.utf8Write) {
-			position += target.utf8Write(key, position, 2000);
 		} else {
-			position += textEncoder.encodeInto(key, target.subarray(position)).written;
+			if (target.utf8Write)
+				position += target.utf8Write(key, position);
+			else
+				position += textEncoder.encodeInto(key, target.subarray(position)).written;
+			if (position > target.length - 4)
+				throw new RangeError('String does not fit in target buffer')
 		}
 		break
 	case 'number':
@@ -209,9 +212,12 @@ function readKey(buffer, start, end, inSequence) {
 	}
 	return value
 }
+const enableNullTermination = () => nullTerminate = true;
+
 const encoder = {
 	writeKey,
 	readKey,
+	enableNullTermination,
 };
 const toBufferKey = (key) => {
 	let buffer = Buffer.alloc(2048);
@@ -276,8 +282,6 @@ function finishUtf8(byte1, src) {
 	}
 }
 
-const enableNullTermination = () => nullTerminate = true;
-
 const readString = eval(makeStringBuilder());
 
 function compareKeys(a, b) {
@@ -330,7 +334,7 @@ const typeOrder = {
 	string: 4
 };
 const MINIMUM_KEY = null;
-const MAXIMUM_KEY = Buffer.from([0xff]);
+const MAXIMUM_KEY = new Uint8Array([0xff]);
 
 exports.MAXIMUM_KEY = MAXIMUM_KEY;
 exports.MINIMUM_KEY = MINIMUM_KEY;

package/index.d.ts

@@ -0,0 +1,19 @@
+type Key = Key[] | string | symbol | number | boolean | Uint8Array;
+/** Writes a key (a primitive value) to the target buffer, starting at the given position */
+export function writeKey(key: Key, target: Uint8Array, position: number, inSequence?: boolean): number;
+/** Reads a key from the provided buffer, from the given range */
+export function readKey(buffer: Uint8Array, start: number, end: number, inSequence?: boolean): Key;
+/** Compares two keys, returning -1 if `a` comes before `b` in the ordered binary representation of the keys, or 1 if `a` comes after `b`, or 0 if they are equivalent */
+export function compareKeys(a: Key, b: Key): number;
+/** The minimum key, with the "first" binary representation (one byte of zero) */
+export const MINIMUM_KEY: null
+/** A maximum key, with a binary representation after all other JS primitives (one byte of 0xff) */
+export const MAXIMUM_KEY: Uint8Array
+/** Enables null termination, ensuring that writing keys to buffers will end with a padding of zeros at the end to complete the following 32-bit word */
+export function enableNullTermination(): void;
+/** An object that holds the functions for encapsulation as a single encoder */
+export const encoder: {
+	writeKey: typeof writeKey,
+	readKey: typeof readKey,
+	enableNullTermination: typeof enableNullTermination,
+}

package/index.js

@@ -62,10 +62,13 @@ export function writeKey(key, target, position, inSequence) {
 					target[position++] = c1 & 0x3f | 0x80
 				}
 			}
-		} else if (target.utf8Write) {
-			position += target.utf8Write(key, position, 2000)
 		} else {
-			position += textEncoder.encodeInto(key, target.subarray(position)).written
+			if (target.utf8Write)
+				position += target.utf8Write(key, position)
+			else
+				position += textEncoder.encodeInto(key, target.subarray(position)).written
+			if (position > target.length - 4)
+				throw new RangeError('String does not fit in target buffer')
 		}
 		break
 	case 'number':
@@ -205,9 +208,12 @@ export function readKey(buffer, start, end, inSequence) {
 	}
 	return value
 }
+export const enableNullTermination = () => nullTerminate = true
+
 export const encoder = {
 	writeKey,
 	readKey,
+	enableNullTermination,
 }
 export const toBufferKey = (key) => {
 	let buffer = Buffer.alloc(2048)
@@ -272,8 +278,6 @@ function finishUtf8(byte1, src) {
 	}
 }
 
-export const enableNullTermination = () => nullTerminate = true
-
 const readString = eval(makeStringBuilder())
 
 export function compareKeys(a, b) {
@@ -326,4 +330,4 @@ const typeOrder = {
 	string: 4
 }
 export const MINIMUM_KEY = null
-export const MAXIMUM_KEY = Buffer.from([0xff])
+export const MAXIMUM_KEY = new Uint8Array([0xff])

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ordered-binary",
   "author": "Kris Zyp",
-  "version": "1.2.0",
+  "version": "1.2.4",
   "description": "Conversion of JavaScript primitives to and from Buffer with binary order matching natural primitive order",
   "license": "MIT",
   "repository": {
@@ -14,6 +14,7 @@
     "test": "mocha tests -u tdd"
   },
   "type": "module",
+  "main": "dist/index.cjs",
   "module": "index.js",
   "exports": {
     ".": {
@@ -30,7 +31,7 @@
   "devDependencies": {
     "@types/node": "latest",
     "chai": "^4",
-    "mocha": "^8.1.3",
-    "rollup": "^1.20.3"
+    "mocha": "^9.2.0",
+    "rollup": "^2.61.1"
   }
 }