bson 7.1.0 → 7.2.0

package/bson.d.ts

@@ -207,6 +207,9 @@ declare namespace BSON {
         Decimal128Extended,
         DoubleExtended,
         EJSONOptions,
+        EJSONOptionsBase,
+        EJSONSerializeOptions,
+        EJSONParseOptions,
         Int32Extended,
         LongExtended,
         MaxKeyExtended,
@@ -465,6 +468,8 @@ export declare type ByteUtils = {
     compare: (buffer1: Uint8Array, buffer2: Uint8Array) => -1 | 0 | 1;
     /** Concatenating all the Uint8Arrays in new Uint8Array. */
     concat: (list: Uint8Array[]) => Uint8Array;
+    /** Copy bytes from source Uint8Array to target Uint8Array */
+    copy: (source: Uint8Array, target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number) => number;
     /** Check if two Uint8Arrays are deep equal */
     equals: (a: Uint8Array, b: Uint8Array) => boolean;
     /** Create a Uint8Array from an array of numbers */
@@ -782,10 +787,13 @@ export declare const EJSON: {
  * @param ejson - The Extended JSON object to deserialize
  * @param options - Optional settings passed to the parse method
  */
-declare function EJSONdeserialize(ejson: Document, options?: EJSONOptions): any;
+declare function EJSONdeserialize(ejson: Document, options?: EJSONParseOptions): any;
 
 /** @public */
-export declare type EJSONOptions = {
+export declare type EJSONOptions = EJSONSerializeOptions & EJSONParseOptions;
+
+/** @public */
+export declare type EJSONOptionsBase = {
     /**
      * Output using the Extended JSON v1 spec
      * @defaultValue `false`
@@ -793,8 +801,13 @@ export declare type EJSONOptions = {
     legacy?: boolean;
     /**
      * Enable Extended JSON's `relaxed` mode, which attempts to return native JS types where possible, rather than BSON types
-     * @defaultValue `false` */
+     * @defaultValue `false`
+     */
     relaxed?: boolean;
+};
+
+/** @public */
+export declare type EJSONParseOptions = EJSONOptionsBase & {
     /**
      * Enable native bigint support
      * @defaultValue `false`
@@ -808,7 +821,16 @@ export declare type EJSONOptions = {
  * @param value - The object to serialize
  * @param options - Optional settings passed to the `stringify` function
  */
-declare function EJSONserialize(value: any, options?: EJSONOptions): Document;
+declare function EJSONserialize(value: any, options?: EJSONSerializeOptions): Document;
+
+/** @public */
+export declare type EJSONSerializeOptions = EJSONOptionsBase & {
+    /**
+     * Omits undefined values from the output instead of converting them to null
+     * @defaultValue `false`
+     */
+    ignoreUndefined?: boolean;
+};
 
 declare type InspectFn = (x: unknown, options?: unknown) => string;
 
@@ -1493,6 +1515,8 @@ export declare interface ObjectIdLike {
 export declare type OnDemand = {
     parseToElements: (this: void, bytes: Uint8Array, startOffset?: number) => Iterable<BSONElement>;
     BSONElement: BSONElement;
+    ByteUtils: ByteUtils;
+    NumberUtils: NumberUtils;
 };
 
 /**
@@ -1517,7 +1541,7 @@ export declare const onDemand: OnDemand;
  * console.log(EJSON.parse(text));
  * ```
  */
-declare function parse(text: string, options?: EJSONOptions): any;
+declare function parse(text: string, options?: EJSONParseOptions): any;
 
 /**
  * Serialize a Javascript object.
@@ -1596,7 +1620,7 @@ export declare function setInternalBufferSize(size: number): void;
  * console.log(EJSON.stringify(doc));
  * ```
  */
-declare function stringify(value: any, replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSONOptions, space?: string | number, options?: EJSONOptions): string;
+declare function stringify(value: any, replacer?: (number | string)[] | ((this: any, key: string, value: any) => any) | EJSONSerializeOptions, space?: string | number, options?: EJSONSerializeOptions): string;
 
 /**
  * @public

package/lib/bson.bundle.js

@@ -262,6 +262,11 @@ const nodeJsByteUtils = {
     concat(list) {
         return Buffer.concat(list);
     },
+    copy(source, target, targetStart, sourceStart, sourceEnd) {
+        return nodeJsByteUtils
+            .toLocalBufferType(source)
+            .copy(target, targetStart ?? 0, sourceStart ?? 0, sourceEnd ?? source.length);
+    },
     equals(a, b) {
         return nodeJsByteUtils.toLocalBufferType(a).equals(b);
     },
@@ -406,6 +411,27 @@ const webByteUtils = {
         }
         return result;
     },
+    copy(source, target, targetStart, sourceStart, sourceEnd) {
+        if (sourceEnd !== undefined && sourceEnd < 0) {
+            throw new RangeError(`The value of "sourceEnd" is out of range. It must be >= 0. Received ${sourceEnd}`);
+        }
+        sourceEnd = sourceEnd ?? source.length;
+        if (sourceStart !== undefined && (sourceStart < 0 || sourceStart > sourceEnd)) {
+            throw new RangeError(`The value of "sourceStart" is out of range. It must be >= 0 and <= ${sourceEnd}. Received ${sourceStart}`);
+        }
+        sourceStart = sourceStart ?? 0;
+        if (targetStart !== undefined && targetStart < 0) {
+            throw new RangeError(`The value of "targetStart" is out of range. It must be >= 0. Received ${targetStart}`);
+        }
+        targetStart = targetStart ?? 0;
+        const srcSlice = source.subarray(sourceStart, sourceEnd);
+        const maxLen = Math.min(srcSlice.length, target.length - targetStart);
+        if (maxLen <= 0) {
+            return 0;
+        }
+        target.set(srcSlice.subarray(0, maxLen), targetStart);
+        return maxLen;
+    },
     equals(uint8Array, otherUint8Array) {
         if (uint8Array.byteLength !== otherUint8Array.byteLength) {
             return false;
@@ -4311,7 +4337,7 @@ function serializeValue(value, options) {
     if (Array.isArray(value))
         return serializeArray(value, options);
     if (value === undefined)
-        return null;
+        return options.ignoreUndefined ? undefined : null;
     if (value instanceof Date || isDate(value)) {
         const dateNum = value.getTime(), inRange = dateNum > -1 && dateNum < 253402318800000;
         if (options.legacy) {
@@ -4595,6 +4621,8 @@ function parseToElements(bytes, startOffset = 0) {
 
 const onDemand = Object.create(null);
 onDemand.parseToElements = parseToElements;
+onDemand.ByteUtils = ByteUtils;
+onDemand.NumberUtils = NumberUtils;
 Object.freeze(onDemand);
 
 const MAXSIZE = 1024 * 1024 * 17;