bson 7.0.0 → 7.1.1

package/bson.d.ts

@@ -236,6 +236,8 @@ declare namespace BSON {
         MaxKey,
         BSONRegExp,
         Decimal128,
+        NumberUtils,
+        ByteUtils,
         BSONValue,
         bsonType,
         BSONTypeTag,
@@ -450,19 +452,27 @@ export declare class BSONVersionError extends BSONError {
  * A collection of functions that help work with data in a Uint8Array.
  * ByteUtils is configured at load time to use Node.js or Web based APIs for the internal implementations.
  */
-declare type ByteUtils = {
+export declare type ByteUtils = {
+    /** Checks if the given value is a Uint8Array. */
+    isUint8Array: (value: unknown) => value is Uint8Array;
     /** Transforms the input to an instance of Buffer if running on node, otherwise Uint8Array */
     toLocalBufferType: (buffer: Uint8Array | ArrayBufferView | ArrayBuffer) => Uint8Array;
     /** Create empty space of size */
     allocate: (size: number) => Uint8Array;
     /** Create empty space of size, use pooled memory when available */
     allocateUnsafe: (size: number) => Uint8Array;
+    /** Compare 2 Uint8Arrays lexicographically */
+    compare: (buffer1: Uint8Array, buffer2: Uint8Array) => -1 | 0 | 1;
+    /** Concatenating all the Uint8Arrays in new Uint8Array. */
+    concat: (list: Uint8Array[]) => Uint8Array;
     /** Check if two Uint8Arrays are deep equal */
     equals: (a: Uint8Array, b: Uint8Array) => boolean;
-    /** Check if two Uint8Arrays are deep equal */
+    /** Create a Uint8Array from an array of numbers */
     fromNumberArray: (array: number[]) => Uint8Array;
     /** Create a Uint8Array from a base64 string */
     fromBase64: (base64: string) => Uint8Array;
+    /** Create a Uint8Array from a UTF8 string */
+    fromUTF8: (utf8: string) => Uint8Array;
     /** Create a base64 string from bytes */
     toBase64: (buffer: Uint8Array) => string;
     /** **Legacy** binary strings are an outdated method of data transfer. Do not add public API support for interpreting this format */
@@ -485,7 +495,16 @@ declare type ByteUtils = {
     swap32: (buffer: Uint8Array) => Uint8Array;
 };
 
-/* Excluded declaration from this release type: ByteUtils */
+/**
+ * This is the only ByteUtils that should be used across the rest of the BSON library.
+ *
+ * The type annotation is important here, it asserts that each of the platform specific
+ * utils implementations are compatible with the common one.
+ *
+ * @public
+ * @experimental
+ */
+export declare const ByteUtils: ByteUtils;
 
 /**
  * Calculate the bson size for a passed in Javascript object.
@@ -1321,7 +1340,7 @@ export declare interface MinKeyExtended {
  *
  * A collection of functions that get or set various numeric types and bit widths from a Uint8Array.
  */
-declare type NumberUtils = {
+export declare type NumberUtils = {
     /** Is true if the current system is big endian. */
     isBigEndian: boolean;
     /**
@@ -1345,7 +1364,7 @@ declare type NumberUtils = {
  * @experimental
  * @public
  */
-declare const NumberUtils: NumberUtils;
+export declare const NumberUtils: NumberUtils;
 
 /**
  * A class representation of the BSON ObjectId type.

package/lib/bson.bundle.js

@@ -233,6 +233,7 @@ const nodejsRandomBytes = (() => {
     }
 })();
 const nodeJsByteUtils = {
+    isUint8Array: isUint8Array,
     toLocalBufferType(potentialBuffer) {
         if (Buffer.isBuffer(potentialBuffer)) {
             return potentialBuffer;
@@ -255,6 +256,12 @@ const nodeJsByteUtils = {
     allocateUnsafe(size) {
         return Buffer.allocUnsafe(size);
     },
+    compare(a, b) {
+        return nodeJsByteUtils.toLocalBufferType(a).compare(b);
+    },
+    concat(list) {
+        return Buffer.concat(list);
+    },
     equals(a, b) {
         return nodeJsByteUtils.toLocalBufferType(a).equals(b);
     },
@@ -264,6 +271,9 @@ const nodeJsByteUtils = {
     fromBase64(base64) {
         return Buffer.from(base64, 'base64');
     },
+    fromUTF8(utf8) {
+        return Buffer.from(utf8, 'utf8');
+    },
     toBase64(buffer) {
         return nodeJsByteUtils.toLocalBufferType(buffer).toString('base64');
     },
@@ -338,6 +348,7 @@ const webRandomBytes = (() => {
 })();
 const HEX_DIGIT = /(\d|[a-f])/i;
 const webByteUtils = {
+    isUint8Array: isUint8Array,
     toLocalBufferType(potentialUint8array) {
         const stringTag = potentialUint8array?.[Symbol.toStringTag] ??
             Object.prototype.toString.call(potentialUint8array);
@@ -364,12 +375,43 @@ const webByteUtils = {
     allocateUnsafe(size) {
         return webByteUtils.allocate(size);
     },
-    equals(a, b) {
-        if (a.byteLength !== b.byteLength) {
+    compare(uint8Array, otherUint8Array) {
+        if (uint8Array === otherUint8Array)
+            return 0;
+        const len = Math.min(uint8Array.length, otherUint8Array.length);
+        for (let i = 0; i < len; i++) {
+            if (uint8Array[i] < otherUint8Array[i])
+                return -1;
+            if (uint8Array[i] > otherUint8Array[i])
+                return 1;
+        }
+        if (uint8Array.length < otherUint8Array.length)
+            return -1;
+        if (uint8Array.length > otherUint8Array.length)
+            return 1;
+        return 0;
+    },
+    concat(uint8Arrays) {
+        if (uint8Arrays.length === 0)
+            return webByteUtils.allocate(0);
+        let totalLength = 0;
+        for (const uint8Array of uint8Arrays) {
+            totalLength += uint8Array.length;
+        }
+        const result = webByteUtils.allocate(totalLength);
+        let offset = 0;
+        for (const uint8Array of uint8Arrays) {
+            result.set(uint8Array, offset);
+            offset += uint8Array.length;
+        }
+        return result;
+    },
+    equals(uint8Array, otherUint8Array) {
+        if (uint8Array.byteLength !== otherUint8Array.byteLength) {
             return false;
         }
-        for (let i = 0; i < a.byteLength; i++) {
-            if (a[i] !== b[i]) {
+        for (let i = 0; i < uint8Array.byteLength; i++) {
+            if (uint8Array[i] !== otherUint8Array[i]) {
                 return false;
             }
         }
@@ -381,6 +423,9 @@ const webByteUtils = {
     fromBase64(base64) {
         return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
     },
+    fromUTF8(utf8) {
+        return new TextEncoder().encode(utf8);
+    },
     toBase64(uint8array) {
         return btoa(webByteUtils.toISO88591(uint8array));
     },
@@ -4616,6 +4661,7 @@ BSONType: BSONType,
 BSONValue: BSONValue,
 BSONVersionError: BSONVersionError,
 Binary: Binary,
+ByteUtils: ByteUtils,
 Code: Code,
 DBRef: DBRef,
 Decimal128: Decimal128,
@@ -4625,6 +4671,7 @@ Int32: Int32,
 Long: Long,
 MaxKey: MaxKey,
 MinKey: MinKey,
+NumberUtils: NumberUtils,
 ObjectId: ObjectId,
 Timestamp: Timestamp,
 UUID: UUID,
@@ -4648,6 +4695,7 @@ exports.BSONType = BSONType;
 exports.BSONValue = BSONValue;
 exports.BSONVersionError = BSONVersionError;
 exports.Binary = Binary;
+exports.ByteUtils = ByteUtils;
 exports.Code = Code;
 exports.DBRef = DBRef;
 exports.Decimal128 = Decimal128;
@@ -4657,6 +4705,7 @@ exports.Int32 = Int32;
 exports.Long = Long;
 exports.MaxKey = MaxKey;
 exports.MinKey = MinKey;
+exports.NumberUtils = NumberUtils;
 exports.ObjectId = ObjectId;
 exports.Timestamp = Timestamp;
 exports.UUID = UUID;