add EncodeOptions#ignoreUndefined to ignore undefined values in maps

README.md

@@ -116,6 +116,7 @@ maxDepth | number | `100`
 initialBufferSize | number | `2048`
 sortKeys | boolean | false
 forceFloat32 | boolean | false
+ignoreUndefined | boolean | false
 context | user-defined | -
 
 ### `decode(buffer: ArrayLike<number> | ArrayBuffer, options?: DecodeOptions): unknown`

src/Encoder.ts

@@ -19,6 +19,7 @@ export class Encoder<ContextType> {
     readonly initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE,
     readonly sortKeys = false,
     readonly forceFloat32 = false,
+    readonly ignoreUndefined = false,
   ) {}
 
   encode(object: unknown, depth: number): void {
@@ -231,12 +232,26 @@ export class Encoder<ContextType> {
     }
   }
 
+  countWithoutUndefined(object: Record<string, unknown>, keys: ReadonlyArray<string>): number {
+    let count = 0;
+
+    for (const key of keys) {
+      if (object[key] !== undefined) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
   encodeMap(object: Record<string, unknown>, depth: number) {
     const keys = Object.keys(object);
     if (this.sortKeys) {
       keys.sort();
     }
-    const size = keys.length;
+
+    const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+
     if (size < 16) {
       // fixmap
       this.writeU8(0x80 + size);
@@ -252,10 +267,13 @@ export class Encoder<ContextType> {
       throw new Error(`Too large map object: ${size}`);
     }
 
-    for (let i = 0; i < size; i++) {
-      const key = keys[i];
-      this.encodeString(key);
-      this.encode(object[key], depth + 1);
+    for (const key of keys) {
+      const value = object[key];
+
+      if (!(this.ignoreUndefined && value === undefined)) {
+        this.encodeString(key);
+        this.encode(value, depth + 1);
+      }
     }
   }
 

src/encode.ts

@@ -15,6 +15,14 @@ export type EncodeOptions<ContextType = undefined> = Partial<
      * Only use it if precisions don't matter.
      */
     forceFloat32: boolean;
+
+    /**
+     * If `true`, an object property with `undefined` value are ignored.
+     * e.g. `{ foo: undefined }` will be encoded as `{}`, as `JSON.stringify()` does.
+     *
+     * The default is `false`. Note that it needs more time to encode.
+     */
+    ignoreUndefined: boolean;
   }>
 > &
   ContextOf<ContextType>;
@@ -38,6 +46,7 @@ export function encode<ContextType>(
     options.initialBufferSize,
     options.sortKeys,
     options.forceFloat32,
+    options.ignoreUndefined,
   );
   encoder.encode(value, 1);
   return encoder.getUint8Array();

test/encode.test.ts

@@ -25,6 +25,23 @@ describe("encode", () => {
     });
   });
 
+  context("ignoreUndefined", () => {
+    it("encodes { foo: undefined } as is by default", () => {
+      assert.deepStrictEqual(decode(encode({ foo: undefined, bar: 42 })), { foo: null, bar: 42 });
+    });
+
+    it("encodes { foo: undefined } as is with `ignoreUndefined: false`", () => {
+      assert.deepStrictEqual(decode(encode({ foo: undefined, bar: 42 }, { ignoreUndefined: false })), {
+        foo: null,
+        bar: 42,
+      });
+    });
+
+    it("encodes { foo: undefined } to {} with `ignoreUndefined: true`", () => {
+      assert.deepStrictEqual(decode(encode({ foo: undefined, bar: 42 }, { ignoreUndefined: true })), { bar: 42 });
+    });
+  });
+
   context("ArrayBuffer as buffer", () => {
     const buffer = encode([1, 2, 3]);
     const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteLength);