fix #212

Author: gfx

CHANGELOG.md

@@ -1,5 +1,10 @@
 # This is the revision history of @msgpack/msgpack
 
+## NEXT
+
+* Let `Encoder#encode()` return a copy of the internal buffer, instead of the reference of the buffer (fix #212).
+  * Introducing `Encoder#encodeSharedRef()` to return the shared reference to the internal buffer.
+
 ## 2.7.2 2022/02/08
 
 https://github.com/msgpack/msgpack-javascript/compare/v2.7.1...v2.7.2

src/Encoder.ts

@@ -23,18 +23,28 @@ export class Encoder<ContextType = undefined> {
     private readonly forceIntegerToFloat = false,
   ) {}
 
-  private getUint8Array(): Uint8Array {
-    return this.bytes.subarray(0, this.pos);
-  }
-
   private reinitializeState() {
     this.pos = 0;
   }
 
+  /**
+   * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+   *
+   * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+   */
+  public encodeSharedRef(object: unknown): Uint8Array {
+    this.reinitializeState();
+    this.doEncode(object, 1);
+    return this.bytes.subarray(0, this.pos);
+  }
+
+  /**
+   * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+   */
   public encode(object: unknown): Uint8Array {
     this.reinitializeState();
     this.doEncode(object, 1);
-    return this.getUint8Array();
+    return this.bytes.slice(0, this.pos);
   }
 
   private doEncode(object: unknown, depth: number): void {

src/encode.ts

@@ -77,5 +77,5 @@ export function encode<ContextType = undefined>(
     options.ignoreUndefined,
     options.forceIntegerToFloat,
   );
-  return encoder.encode(value);
+  return encoder.encodeSharedRef(value);
 }

test/reuse-instances.test.ts

@@ -1,5 +1,5 @@
 import { deepStrictEqual } from "assert";
-import { Encoder, Decoder } from "@msgpack/msgpack";
+import { Encoder, Decoder, decode } from "@msgpack/msgpack";
 
 const createStream = async function* (...args: any) {
   for (const item of args) {
@@ -108,5 +108,47 @@ describe("shared instances", () => {
         deepStrictEqual(a, [[object]], `#${i}`);
       }
     });
+
+    context("regression #212", () => {
+      it("runs multiple times", () => {
+        const encoder = new Encoder();
+        const decoder = new Decoder();
+
+        const data1 = {
+          isCommunication: false,
+          isWarning: false,
+          alarmId: "619f65a2774abf00568b7210",
+          intervalStart: "2022-05-20T12:00:00.000Z",
+          intervalStop: "2022-05-20T13:00:00.000Z",
+          triggeredAt: "2022-05-20T13:00:00.000Z",
+          component: "someComponent",
+          _id: "6287920245a582301475627d",
+        };
+
+        const data2 = {
+          foo: "bar",
+        };
+
+        const arr = [data1, data2];
+        const enc = arr.map((x) => [x, encoder.encode(x)] as const);
+
+        enc.forEach(([orig, acc]) => {
+          const des = decoder.decode(acc);
+          deepStrictEqual(des, orig);
+        });
+      });
+    });
+
+    context("Encoder#encodeSharedRef()", () => {
+      it("returns the shared reference", () => {
+        const encoder = new Encoder();
+
+        const a = encoder.encodeSharedRef(true);
+        const b = encoder.encodeSharedRef(false);
+
+        deepStrictEqual(decode(a), decode(b)); // yes, this is the expected behavior
+        deepStrictEqual(a.buffer, b.buffer);
+      });
+    });
   });
 });