feat: add createTupleson fn and more

package.json

@@ -18,6 +18,7 @@
 	],
 	"scripts": {
 		"build": "tsup",
+		"fix": "pnpm lint --fix && pnpm format:write",
 		"format": "prettier \"**/*\" --ignore-unknown",
 		"format:write": "pnpm format --write",
 		"lint": "eslint . .*js --max-warnings 0 --report-unused-disable-directives",
@@ -32,6 +33,7 @@
 	},
 	"devDependencies": {
 		"@release-it/conventional-changelog": "^7.0.2",
+		"@tsconfig/strictest": "^2.0.2",
 		"@types/eslint": "^8.44.3",
 		"@typescript-eslint/eslint-plugin": "^6.7.3",
 		"@typescript-eslint/parser": "^6.7.3",

src/handlers/index.ts

@@ -0,0 +1,8 @@
+export * from "./tsonBigint.js";
+export * from "./tsonDate.js";
+export * from "./tsonRegExp.js";
+export * from "./tsonSet.js";
+export * from "./tsonMap.js";
+export * from "./tsonUndefined.js";
+export * from "./tsonUnknownObjectGuard.js";
+export * from "./tsonNumber.js";

src/handlers/tsonBigint.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from "vitest";
+
+import { createTupleson } from "../tson.js";
+import { tsonBigint } from "./tsonBigint.js";
+import { tsonMap } from "./tsonMap.js";
+import { tsonSet } from "./tsonSet.js";
+
+test("bigint", () => {
+	const t = createTupleson({
+		types: [tsonMap, tsonSet, tsonBigint],
+	});
+
+	{
+		// bigint
+		const expected = 1n;
+
+		const stringified = t.stringify(expected);
+		const deserialized = t.parse(stringified);
+
+		expect(deserialized).toEqual(expected);
+
+		{
+			// set of BigInt
+			const expected = new Set([1n]);
+
+			const stringified = t.stringify(expected);
+			const deserialized = t.parse(stringified);
+
+			expect(deserialized).toEqual(expected);
+		}
+
+		{
+			// set of a map of bigint
+			const expected = new Set([new Map([["a", 1n]])]);
+
+			const stringified = t.stringify(expected);
+			const deserialized = t.parse(stringified);
+
+			expect(deserialized).toEqual(expected);
+		}
+	}
+});

src/handlers/tsonBigint.ts

@@ -0,0 +1,8 @@
+import { TsonType } from "../types.js";
+
+export const tsonBigint: TsonType<bigint, string> = {
+	deserialize: (v) => BigInt(v),
+	key: "bigint",
+	primitive: "bigint",
+	serialize: (v) => v.toString(),
+};

src/handlers/tsonDate.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+
+import { createTupleson } from "../tson.js";
+import { tsonDate } from "./tsonDate.js";
+
+test("Date", () => {
+	const ctx = createTupleson({
+		types: [tsonDate],
+	});
+
+	const date = new Date();
+
+	const stringified = ctx.stringify(date);
+	const deserialized = ctx.parse(stringified);
+	expect(deserialized).toEqual(date);
+});

src/handlers/tsonDate.ts

@@ -0,0 +1,8 @@
+import { TsonType } from "../types.js";
+
+export const tsonDate: TsonType<Date, string> = {
+	deserialize: (value) => new Date(value),
+	key: "Date",
+	serialize: (value) => value.toJSON(),
+	test: (value) => value instanceof Date,
+};

src/handlers/tsonMap.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+
+import { createTupleson } from "../tson.js";
+import { tsonMap } from "./tsonMap.js";
+
+test("Map", () => {
+	const t = createTupleson({
+		types: [tsonMap],
+	});
+
+	const expected = new Map([["a", "b"]]);
+
+	const stringified = t.stringify(expected);
+	const deserialized = t.parse(stringified);
+	expect(deserialized).toEqual(expected);
+});

src/handlers/tsonMap.ts

@@ -0,0 +1,8 @@
+import { TsonType } from "../types.js";
+
+export const tsonMap: TsonType<Map<unknown, unknown>, [unknown, unknown][]> = {
+	deserialize: (v) => new Map(v),
+	key: "Map",
+	serialize: (v) => Array.from(v.entries()),
+	test: (v) => v instanceof Map,
+};

src/handlers/tsonNumber.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "vitest";
+
+import { expectError } from "../testUtils.js";
+import { createTupleson } from "../tson.js";
+import { tsonNumber } from "./tsonNumber.js";
+
+test("number", () => {
+	const t = createTupleson({
+		types: [tsonNumber],
+	});
+
+	const bad = [
+		//
+		NaN,
+		Infinity,
+		-Infinity,
+	];
+	const good = [1, 0, -1, 1.1, -1.1];
+
+	const errors: unknown[] = [];
+
+	for (const n of bad) {
+		const err = expectError(() => t.parse(t.stringify(n)));
+		errors.push(err);
+	}
+
+	expect(errors).toMatchInlineSnapshot(`
+		[
+		  [Error: Encountered NaN],
+		  [Error: Encountered Infinity],
+		  [Error: Encountered Infinity],
+		]
+	`);
+
+	for (const n of good) {
+		const deserialized = t.parse(t.stringify(n));
+		expect(deserialized).toEqual(n);
+	}
+});

src/handlers/tsonNumber.ts

@@ -0,0 +1,21 @@
+import { TsonType } from "../types.js";
+
+/**
+ * Prevents `NaN` and `Infinity` from being serialized
+ */
+
+export const tsonNumber: TsonType<number, number> = {
+	primitive: "number",
+	test: (v) => {
+		const value = v as number;
+		if (isNaN(value)) {
+			throw new Error("Encountered NaN");
+		}
+
+		if (!isFinite(value)) {
+			throw new Error("Encountered Infinity");
+		}
+
+		return false;
+	},
+};

src/handlers/tsonRegExp.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from "vitest";
+
+import { createTupleson } from "../tson.js";
+import { tsonRegExp } from "./index.js";
+
+test("regex", () => {
+	const t = createTupleson({
+		types: [tsonRegExp],
+	});
+
+	const expected = /foo/g;
+
+	const stringified = t.stringify(expected, 2);
+
+	expect(stringified).toMatchInlineSnapshot(
+		`
+		"{
+		  \\"json\\": [
+		    \\"RegExp\\",
+		    \\"/foo/g\\",
+		    \\"__tson\\"
+		  ],
+		  \\"nonce\\": \\"__tson\\"
+		}"
+	`,
+	);
+
+	const deserialized = t.parse(stringified);
+
+	expect(deserialized).toBeInstanceOf(RegExp);
+	expect(deserialized).toMatchInlineSnapshot("/foo/g");
+	expect(deserialized + "").toEqual(expected + "");
+});

src/handlers/tsonRegExp.ts

@@ -0,0 +1,12 @@
+import { TsonType } from "../types.js";
+
+export const tsonRegExp: TsonType<RegExp, string> = {
+	deserialize: (str) => {
+		const body = str.slice(1, str.lastIndexOf("/"));
+		const flags = str.slice(str.lastIndexOf("/") + 1);
+		return new RegExp(body, flags);
+	},
+	key: "RegExp",
+	serialize: (value) => "" + value,
+	test: (value) => value instanceof RegExp,
+};

src/handlers/tsonSet.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+
+import { createTupleson } from "../tson.js";
+import { tsonSet } from "./tsonSet.js";
+
+test("Set", () => {
+	const t = createTupleson({
+		types: [tsonSet],
+	});
+
+	const expected = new Set(["a", "b"]);
+
+	const stringified = t.stringify(expected);
+	const deserialized = t.parse(stringified);
+	expect(deserialized).toEqual(expected);
+});

src/handlers/tsonSet.ts

@@ -0,0 +1,8 @@
+import { TsonType } from "../types.js";
+
+export const tsonSet: TsonType<Set<unknown>, unknown[]> = {
+	deserialize: (v) => new Set(v),
+	key: "Set",
+	serialize: (v) => Array.from(v),
+	test: (v) => v instanceof Set,
+};