bson 6.8.0 → 6.9.0

package/src/parser/utils.ts

@@ -1,31 +1,65 @@
+const map = new WeakMap<object, string>();
+
+const TYPES = {
+  ArrayBuffer: '[object ArrayBuffer]',
+  SharedArrayBuffer: '[object SharedArrayBuffer]',
+  Uint8Array: '[object Uint8Array]',
+  BigInt64Array: '[object BigInt64Array]',
+  BigUint64Array: '[object BigUint64Array]',
+  RegExp: '[object RegExp]',
+  Map: '[object Map]',
+  Date: '[object Date]'
+};
+
+/**
+ * Retrieves the prototype.toString() of a value.
+ * If the value is an object, it will cache the result in a WeakMap for future use.
+ */
+function getPrototypeString(value: unknown): string {
+  let str = map.get(value as object);
+
+  if (!str) {
+    str = Object.prototype.toString.call(value);
+    if (value !== null && typeof value === 'object') {
+      map.set(value, str);
+    }
+  }
+  return str;
+}
+
 export function isAnyArrayBuffer(value: unknown): value is ArrayBuffer {
-  return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(
-    Object.prototype.toString.call(value)
-  );
+  const type = getPrototypeString(value);
+  return type === TYPES.ArrayBuffer || type === TYPES.SharedArrayBuffer;
 }
 
 export function isUint8Array(value: unknown): value is Uint8Array {
-  return Object.prototype.toString.call(value) === '[object Uint8Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.Uint8Array;
 }
 
 export function isBigInt64Array(value: unknown): value is BigInt64Array {
-  return Object.prototype.toString.call(value) === '[object BigInt64Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.BigInt64Array;
 }
 
 export function isBigUInt64Array(value: unknown): value is BigUint64Array {
-  return Object.prototype.toString.call(value) === '[object BigUint64Array]';
+  const type = getPrototypeString(value);
+  return type === TYPES.BigUint64Array;
 }
 
 export function isRegExp(d: unknown): d is RegExp {
-  return Object.prototype.toString.call(d) === '[object RegExp]';
+  const type = getPrototypeString(d);
+  return type === TYPES.RegExp;
 }
 
 export function isMap(d: unknown): d is Map<unknown, unknown> {
-  return Object.prototype.toString.call(d) === '[object Map]';
+  const type = getPrototypeString(d);
+  return type === TYPES.Map;
 }
 
 export function isDate(d: unknown): d is Date {
-  return Object.prototype.toString.call(d) === '[object Date]';
+  const type = getPrototypeString(d);
+  return type === TYPES.Date;
 }
 
 export type InspectFn = (x: unknown, options?: unknown) => string;

package/src/timestamp.ts

@@ -28,6 +28,8 @@ export interface TimestampExtended {
 /**
  * @public
  * @category BSONType
+ *
+ * A special type for _internal_ MongoDB use and is **not** associated with the regular Date type.
  */
 export class Timestamp extends LongWithoutOverridesClass {
   get _bsontype(): 'Timestamp' {
@@ -36,6 +38,20 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
+  /**
+   * An incrementing ordinal for operations within a given second.
+   */
+  get i(): number {
+    return this.low >>> 0;
+  }
+
+  /**
+   * A `time_t` value measuring seconds since the Unix epoch
+   */
+  get t(): number {
+    return this.high >>> 0;
+  }
+
   /**
    * @param int - A 64-bit bigint representing the Timestamp.
    */
@@ -127,7 +143,7 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   /** @internal */
   toExtendedJSON(): TimestampExtended {
-    return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
+    return { $timestamp: { t: this.t, i: this.i } };
   }
 
   /** @internal */
@@ -144,8 +160,8 @@ export class Timestamp extends LongWithoutOverridesClass {
 
   inspect(depth?: number, options?: unknown, inspect?: InspectFn): string {
     inspect ??= defaultInspect;
-    const t = inspect(this.high >>> 0, options);
-    const i = inspect(this.low >>> 0, options);
+    const t = inspect(this.t, options);
+    const i = inspect(this.i, options);
     return `new Timestamp({ t: ${t}, i: ${i} })`;
   }
 }