let Encoder and Decoder accept named params as encode() and decode() do

Author: gfx

src/Decoder.ts

@@ -5,6 +5,61 @@ import { utf8Decode } from "./utils/utf8";
 import { createDataView, ensureUint8Array } from "./utils/typedArrays";
 import { CachedKeyDecoder, KeyDecoder } from "./CachedKeyDecoder";
 import { DecodeError } from "./DecodeError";
+import type { ContextOf } from "./context";
+
+export type DecoderOptions<ContextType = undefined> = Readonly<
+  Partial<{
+    extensionCodec: ExtensionCodecType<ContextType>;
+
+    /**
+     * Decodes Int64 and Uint64 as bigint if it's set to true.
+     * Depends on ES2020's {@link DataView#getBigInt64} and
+     * {@link DataView#getBigUint64}.
+     *
+     * Defaults to false.
+     */
+    useBigInt64: boolean;
+
+    /**
+     * Maximum string length.
+     *
+     * Defaults to 4_294_967_295 (UINT32_MAX).
+     */
+    maxStrLength: number;
+    /**
+     * Maximum binary length.
+     *
+     * Defaults to 4_294_967_295 (UINT32_MAX).
+     */
+    maxBinLength: number;
+    /**
+     * Maximum array length.
+     *
+     * Defaults to 4_294_967_295 (UINT32_MAX).
+     */
+    maxArrayLength: number;
+    /**
+     * Maximum map length.
+     *
+     * Defaults to 4_294_967_295 (UINT32_MAX).
+     */
+    maxMapLength: number;
+    /**
+     * Maximum extension length.
+     *
+     * Defaults to 4_294_967_295 (UINT32_MAX).
+     */
+    maxExtLength: number;
+
+    /**
+     * An object key decoder. Defaults to the shared instance of {@link CachedKeyDecoder}.
+     * `null` is a special value to disable the use of the key decoder at all.
+     */
+    keyDecoder: KeyDecoder | null;
+  }>
+> &
+  ContextOf<ContextType>;
+
 
 const STATE_ARRAY = "array";
 const STATE_MAP_KEY = "map_key";
@@ -54,6 +109,16 @@ const MORE_DATA = new DataViewIndexOutOfBoundsError("Insufficient data");
 const sharedCachedKeyDecoder = new CachedKeyDecoder();
 
 export class Decoder<ContextType = undefined> {
+  private readonly extensionCodec: ExtensionCodecType<ContextType>;
+  private readonly context: ContextType;
+  private readonly useBigInt64: boolean;
+  private readonly maxStrLength: number;
+  private readonly maxBinLength: number;
+  private readonly maxArrayLength: number;
+  private readonly maxMapLength: number;
+  private readonly maxExtLength: number;
+  private readonly keyDecoder: KeyDecoder | null;
+
   private totalPos = 0;
   private pos = 0;
 
@@ -62,17 +127,18 @@ export class Decoder<ContextType = undefined> {
   private headByte = HEAD_BYTE_REQUIRED;
   private readonly stack: Array<StackState> = [];
 
-  public constructor(
-    private readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
-    private readonly context: ContextType = undefined as any,
-    private readonly useBigInt64 = false,
-    private readonly maxStrLength = UINT32_MAX,
-    private readonly maxBinLength = UINT32_MAX,
-    private readonly maxArrayLength = UINT32_MAX,
-    private readonly maxMapLength = UINT32_MAX,
-    private readonly maxExtLength = UINT32_MAX,
-    private readonly keyDecoder: KeyDecoder | null = sharedCachedKeyDecoder,
-  ) {}
+  public constructor(options?: DecoderOptions<ContextType>) {
+    this.extensionCodec = options?.extensionCodec ?? (ExtensionCodec.defaultCodec as ExtensionCodecType<ContextType>);
+    this.context = (options as { context: ContextType } | undefined)?.context as ContextType; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
+
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxStrLength = options?.maxStrLength ?? UINT32_MAX;
+    this.maxBinLength = options?.maxBinLength ?? UINT32_MAX;
+    this.maxArrayLength = options?.maxArrayLength ?? UINT32_MAX;
+    this.maxMapLength = options?.maxMapLength ?? UINT32_MAX;
+    this.maxExtLength = options?.maxExtLength ?? UINT32_MAX;
+    this.keyDecoder = (options?.keyDecoder !== undefined) ? options.keyDecoder : sharedCachedKeyDecoder;
+  }
 
   private reinitializeState() {
     this.totalPos = 0;

src/Encoder.ts

@@ -3,26 +3,105 @@ import { ExtensionCodec, ExtensionCodecType } from "./ExtensionCodec";
 import { setInt64, setUint64 } from "./utils/int";
 import { ensureUint8Array } from "./utils/typedArrays";
 import type { ExtData } from "./ExtData";
+import type { ContextOf, SplitUndefined } from "./context";
+
 
 export const DEFAULT_MAX_DEPTH = 100;
 export const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
 
+export type EncoderOptions<ContextType = undefined> = Partial<
+  Readonly<{
+    extensionCodec: ExtensionCodecType<ContextType>;
+
+    /**
+     * Encodes bigint as Int64 or Uint64 if it's set to true.
+     * {@link forceIntegerToFloat} does not affect bigint.
+     * Depends on ES2020's {@link DataView#setBigInt64} and
+     * {@link DataView#setBigUint64}.
+     *
+     * Defaults to false.
+     */
+    useBigInt64: boolean;
+
+    /**
+     * The maximum depth in nested objects and arrays.
+     *
+     * Defaults to 100.
+     */
+    maxDepth: number;
+
+    /**
+     * The initial size of the internal buffer.
+     *
+     * Defaults to 2048.
+     */
+    initialBufferSize: number;
+
+    /**
+     * If `true`, the keys of an object is sorted. In other words, the encoded
+     * binary is canonical and thus comparable to another encoded binary.
+     *
+     * Defaults to `false`. If enabled, it spends more time in encoding objects.
+     */
+    sortKeys: boolean;
+    /**
+     * If `true`, non-integer numbers are encoded in float32, not in float64 (the default).
+     *
+     * Only use it if precisions don't matter.
+     *
+     * Defaults to `false`.
+     */
+    forceFloat32: boolean;
+
+    /**
+     * If `true`, an object property with `undefined` value are ignored.
+     * e.g. `{ foo: undefined }` will be encoded as `{}`, as `JSON.stringify()` does.
+     *
+     * Defaults to `false`. If enabled, it spends more time in encoding objects.
+     */
+    ignoreUndefined: boolean;
+
+    /**
+     * If `true`, integer numbers are encoded as floating point numbers,
+     * with the `forceFloat32` option taken into account.
+     *
+     * Defaults to `false`.
+     */
+    forceIntegerToFloat: boolean;
+  }>
+> & ContextOf<ContextType>;
+
 export class Encoder<ContextType = undefined> {
-  private pos = 0;
-  private view = new DataView(new ArrayBuffer(this.initialBufferSize));
-  private bytes = new Uint8Array(this.view.buffer);
-
-  public constructor(
-    private readonly extensionCodec: ExtensionCodecType<ContextType> = ExtensionCodec.defaultCodec as any,
-    private readonly context: ContextType = undefined as any,
-    private readonly useBigInt64 = false,
-    private readonly maxDepth = DEFAULT_MAX_DEPTH,
-    private readonly initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE,
-    private readonly sortKeys = false,
-    private readonly forceFloat32 = false,
-    private readonly ignoreUndefined = false,
-    private readonly forceIntegerToFloat = false,
-  ) {}
+  private readonly extensionCodec: ExtensionCodecType<ContextType>;
+  private readonly context: ContextType;
+  private readonly useBigInt64: boolean;
+  private readonly maxDepth: number;
+  private readonly initialBufferSize: number;
+  private readonly sortKeys: boolean;
+  private readonly forceFloat32: boolean;
+  private readonly ignoreUndefined: boolean;
+  private readonly forceIntegerToFloat: boolean;
+
+  private pos: number;
+  private view: DataView;
+  private bytes: Uint8Array;
+
+  public constructor(options?: EncoderOptions<ContextType>) {
+    this.extensionCodec = options?.extensionCodec ?? (ExtensionCodec.defaultCodec as ExtensionCodecType<ContextType>);
+    this.context = (options as { context: ContextType } | undefined)?.context as ContextType; // needs a type assertion because EncoderOptions has no context property when ContextType is undefined
+
+    this.useBigInt64 = options?.useBigInt64 ?? false;
+    this.maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this.initialBufferSize = options?.initialBufferSize ?? DEFAULT_INITIAL_BUFFER_SIZE;
+    this.sortKeys = options?.sortKeys ?? false;
+    this.forceFloat32 = options?.forceFloat32 ?? false;
+    this.ignoreUndefined = options?.ignoreUndefined ?? false;
+    this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+
+    this.pos = 0;
+    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+    this.bytes = new Uint8Array(this.view.buffer);
+  }
 
   private reinitializeState() {
     this.pos = 0;

src/decode.ts

@@ -1,55 +1,16 @@
 import { Decoder } from "./Decoder";
-import type { ExtensionCodecType } from "./ExtensionCodec";
-import type { ContextOf, SplitUndefined } from "./context";
+import type { DecoderOptions } from "./Decoder";
+import type { SplitUndefined } from "./context";
 
-export type DecodeOptions<ContextType = undefined> = Readonly<
-  Partial<{
-    extensionCodec: ExtensionCodecType<ContextType>;
-
-    /**
-     * Decodes Int64 and Uint64 as bigint if it's set to true.
-     * Depends on ES2020's {@link DataView#getBigInt64} and
-     * {@link DataView#getBigUint64}.
-     *
-     * Defaults to false.
-     */
-    useBigInt64: boolean;
-
-    /**
-     * Maximum string length.
-     *
-     * Defaults to 4_294_967_295 (UINT32_MAX).
-     */
-    maxStrLength: number;
-    /**
-     * Maximum binary length.
-     *
-     * Defaults to 4_294_967_295 (UINT32_MAX).
-     */
-    maxBinLength: number;
-    /**
-     * Maximum array length.
-     *
-     * Defaults to 4_294_967_295 (UINT32_MAX).
-     */
-    maxArrayLength: number;
-    /**
-     * Maximum map length.
-     *
-     * Defaults to 4_294_967_295 (UINT32_MAX).
-     */
-    maxMapLength: number;
-    /**
-     * Maximum extension length.
-     *
-     * Defaults to 4_294_967_295 (UINT32_MAX).
-     */
-    maxExtLength: number;
-  }>
-> &
-  ContextOf<ContextType>;
+/**
+ * @deprecated Use {@link DecoderOptions} instead.
+ */
+export type DecodeOptions = never;
 
-export const defaultDecodeOptions: DecodeOptions = {};
+/**
+ * @deprecated No longer supported.
+ */
+export const defaultDecodeOptions: never = undefined as never;
 
 /**
  * It decodes a single MessagePack object in a buffer.
@@ -62,18 +23,9 @@ export const defaultDecodeOptions: DecodeOptions = {};
  */
 export function decode<ContextType = undefined>(
   buffer: ArrayLike<number> | BufferSource,
-  options: DecodeOptions<SplitUndefined<ContextType>> = defaultDecodeOptions as any,
+  options?: DecoderOptions<SplitUndefined<ContextType>>,
 ): unknown {
-  const decoder = new Decoder(
-    options.extensionCodec,
-    (options as typeof options & { context: any }).context,
-    options.useBigInt64,
-    options.maxStrLength,
-    options.maxBinLength,
-    options.maxArrayLength,
-    options.maxMapLength,
-    options.maxExtLength,
-  );
+  const decoder = new Decoder(options);
   return decoder.decode(buffer);
 }
 
@@ -86,17 +38,8 @@ export function decode<ContextType = undefined>(
  */
 export function decodeMulti<ContextType = undefined>(
   buffer: ArrayLike<number> | BufferSource,
-  options: DecodeOptions<SplitUndefined<ContextType>> = defaultDecodeOptions as any,
+  options?: DecoderOptions<SplitUndefined<ContextType>>,
 ): Generator<unknown, void, unknown> {
-  const decoder = new Decoder(
-    options.extensionCodec,
-    (options as typeof options & { context: any }).context,
-    options.useBigInt64,
-    options.maxStrLength,
-    options.maxBinLength,
-    options.maxArrayLength,
-    options.maxMapLength,
-    options.maxExtLength,
-  );
+  const decoder = new Decoder(options);
   return decoder.decodeMulti(buffer);
 }