superjson dates maps sets bigint undefined: working versions (tested 2026-10-16)

{
  "name": "superjson-dates-maps",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "superjson": "2.2.6"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import superjson, { type SuperJSONResult } from "superjson";

export function encode(value: unknown): string {
  return superjson.stringify(value);
}

export function decode<T>(text: string): T {
  return superjson.parse<T>(text);
}

export function serialize<T>(value: T): SuperJSONResult {
  return superjson.serialize(value);
}

export function deserialize<T>(payload: SuperJSONResult): T {
  return superjson.deserialize<T>(payload);
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { decode, deserialize, encode, serialize } from "../src/codec.ts";

type Payload = {
  when: Date;
  map: Map<string, number>;
  set: Set<string>;
  big: bigint;
  missing: undefined;
};

function sample(): Payload {
  return {
    when: new Date("2024-01-02T03:04:05.000Z"),
    map: new Map<string, number>([
      ["a", 1],
      ["b", 2],
    ]),
    set: new Set<string>(["x", "y"]),
    big: 9007199254740993n,
    missing: undefined,
  };
}

test("round trips Date, Map, Set, BigInt and undefined", () => {
  const back = decode<Payload>(encode(sample()));

  assert.ok(back.when instanceof Date);
  assert.equal(back.when.toISOString(), "2024-01-02T03:04:05.000Z");

  assert.ok(back.map instanceof Map);
  assert.deepEqual([...back.map.entries()], [
    ["a", 1],
    ["b", 2],
  ]);

  assert.ok(back.set instanceof Set);
  assert.deepEqual([...back.set.values()], ["x", "y"]);

  assert.equal(typeof back.big, "bigint");
  assert.equal(back.big, 9007199254740993n);

  assert.ok("missing" in back);
  assert.equal(back.missing, undefined);
});

test("exposes the json and meta annotations", () => {
  const result = serialize(sample());
  const json = result.json as Record<string, unknown>;
  const meta = result.meta as { values?: Record<string, string[]> };

  assert.deepEqual(json.when, "2024-01-02T03:04:05.000Z");
  assert.deepEqual(json.map, [
    ["a", 1],
    ["b", 2],
  ]);
  assert.deepEqual(json.set, ["x", "y"]);
  assert.equal(json.big, "9007199254740993");
  assert.equal(json.missing, null);

  assert.deepEqual(meta.values, {
    when: ["Date"],
    map: ["map"],
    set: ["set"],
    big: ["bigint"],
    missing: ["undefined"],
  });
});

test("stringify and serialize produce equivalent payloads", () => {
  const fromString = decode<Payload>(encode(sample()));
  const fromObject = deserialize<Payload>(serialize(sample()));

  assert.deepEqual(fromObject, fromString);
});