feat: add classNames

README.md

@@ -191,6 +191,36 @@ const user = serializer.deserialize(serialized);
 console.log(user); // TestUser { name: "wan2land", age: 20 }
 ```
 
+#### Alias
+
+If you want to serialize a class with a different name, you can use the
+`classes` option.
+
+```ts
+class TestUser {
+ constructor(
+ public name?: string,
+ public age?: number,
+ ) {
+ }
+}
+
+const serializer = new Serializer({
+ classes: {
+ AliasTestUser: TestUser,
+ },
+});
+```
+
+```ts
+const serialized = serializer.serialize(new TestUser("wan2land", 20));
+console.log(serialized);
+// AliasTestUser{"name":"wan2land","age":20} <--- AliasTestUser
+
+const user = serializer.deserialize(serialized);
+console.log(user); // TestUser { name: "wan2land", age: 20 }
+```
+
 #### toSerialize / toDeserialize
 
 Private variables can be converted using two special symbols (`toSerialize`,

deserialize.ts

@@ -1,6 +1,6 @@
-import { AstAny, AstRoot, parse } from "./parse.ts";
+import { type AstAny, type AstRoot, parse } from "./parse.ts";
 import { toDeserialize } from "./symbol.ts";
-import { ConstructType } from "./types.ts";
+import type { ConstructType } from "./types.ts";
 
 export type ClassLoadHandler = (
  name: string,

serialize.test.ts

@@ -205,6 +205,22 @@ Deno.test("serialize class", () => {
  );
 });
 
+Deno.test("serialize class with alias", () => {
+ class TestUser {
+ #_privateSomething = 1;
+ publicSomething = 2;
+ constructor(public name: string, public age: number) {
+ }
+ }
+
+ const user = new TestUser("wan2land", 20);
+
+ assertEquals(
+ serialize(user, { classNames: new Map([[TestUser, "AliasedTestUser"]]) }),
+ 'AliasedTestUser{"name":"wan2land","age":20,"publicSomething":2}',
+ );
+});
+
 Deno.test("serialize class with private", () => {
  class TestUser {
  #_privateSomething = 1;

serialize.ts

@@ -1,7 +1,9 @@
 // deno-lint-ignore-file no-explicit-any
 import { toSerialize } from "./symbol.ts";
+import type { ConstructType } from "./types.ts";
 
 export interface SerializeOptions {
+ classNames?: Map<ConstructType<unknown>, string>;
  prettify?: boolean;
 }
 
@@ -127,7 +129,7 @@ export function serialize(value: any, options: SerializeOptions = {}): string {
 
  const name = value.constructor && value.constructor !== Object &&
  value.constructor !== Function
- ? value.constructor.name
+ ? (options.classNames?.get(value.constructor) ?? value.constructor.name)
  : "";
 
  _stringifyListStart(prettify && name ? `${name} {` : `${name}{`);

serializer.test.ts

@@ -54,3 +54,28 @@ Deno.test("serializer, toSerialize, toDeserialize", () => {
  assertEquals(user.getAge(), 20);
  }
 });
+
+Deno.test("serializer, alias class names", () => {
+ class TestUser {
+ constructor(public name: string) {
+ }
+ }
+
+ const serializer = new Serializer({ classes: { AliasedTestUser: TestUser } });
+ {
+ const user = new TestUser("wan2land");
+
+ assertEquals(
+ serializer.serialize(user),
+ 'AliasedTestUser{"name":"wan2land"}',
+ );
+ }
+ {
+ const user = serializer.deserialize<TestUser>(
+ 'AliasedTestUser{"name":"wan2land"}',
+ );
+
+ assertInstanceOf(user, TestUser);
+ assertEquals(user.name, "wan2land");
+ }
+});

serializer.ts

@@ -1,21 +1,39 @@
-import { serialize, SerializeOptions } from "./serialize.ts";
-import { ClassLoadHandler, deserialize } from "./deserialize.ts";
-import { ConstructType } from "./types.ts";
+import {
+ type ClassLoadHandler,
+ deserialize,
+ type DeserializeOptions,
+} from "./deserialize.ts";
+import { serialize, type SerializeOptions } from "./serialize.ts";
+import type { ConstructType } from "./types.ts";
 
 export interface SerializerOptions {
  classes?: { [className: string]: ConstructType<unknown> };
  loadClass?: ClassLoadHandler;
 }
 
 export class Serializer {
+ #classNames?: Map<ConstructType<unknown>, string>;
+
  constructor(public options?: SerializerOptions) {
  }
 
- serialize(value: unknown, options?: SerializeOptions): string {
- return serialize(value, options);
+ serialize(value: unknown, options: SerializeOptions = {}): string {
+ return serialize(value, {
+ prettify: options.prettify,
+ classNames: options.classNames ?? (
+ this.#classNames ??= new Map(
+ Object.entries(this.options?.classes ?? {}).map((
+ [key, value],
+ ) => [value, key]),
+ )
+ ),
+ });
  }
 
- deserialize<T = unknown>(code: string): T {
- return deserialize<T>(code, this.options);
+ deserialize<T = unknown>(code: string, options: DeserializeOptions = {}): T {
+ return deserialize<T>(code, {
+ classes: options?.classes ?? this.options?.classes,
+ loadClass: options?.loadClass ?? this.options?.loadClass,
+ });
  }
 }