Add support for reviving symbols

src/class-registry.ts

@@ -1,67 +1,4 @@
+import { Registry } from './registry';
 import { Class } from './types';
 
-class DoubleIndexedKV<K, V> {
-  keyToValue = new Map<K, V>();
-  valueToKey = new Map<V, K>();
-
-  set(key: K, value: V) {
-    this.keyToValue.set(key, value);
-    this.valueToKey.set(value, key);
-  }
-
-  deleteByValue(value: V) {
-    this.valueToKey.delete(value);
-    this.keyToValue.forEach((otherValue, otherKey) => {
-      if (value === otherValue) {
-        this.keyToValue.delete(otherKey);
-      }
-    });
-  }
-
-  getByKey(key: K): V | undefined {
-    return this.keyToValue.get(key);
-  }
-
-  getByValue(value: V): K | undefined {
-    return this.valueToKey.get(value);
-  }
-
-  clear() {
-    this.keyToValue.clear();
-    this.valueToKey.clear();
-  }
-}
-
-const classRegistry = new DoubleIndexedKV<string, Class>();
-
-export function registerClass(clazz: Class, identifier?: string): void {
-  if (classRegistry.getByValue(clazz)) {
-    return;
-  }
-
-  if (!identifier) {
-    identifier = clazz.name;
-  }
-
-  if (classRegistry.getByKey(identifier)) {
-    throw new Error('Ambiguous class, provide a unique identifier.');
-  }
-
-  classRegistry.set(identifier, clazz);
-}
-
-export function unregisterClass(clazz: Class): void {
-  classRegistry.deleteByValue(clazz);
-}
-
-export function clear(): void {
-  classRegistry.clear();
-}
-
-export function getIdentifier(clazz: Class) {
-  return classRegistry.getByValue(clazz);
-}
-
-export function getClass(identifier: string) {
-  return classRegistry.getByKey(identifier);
-}
+export const ClassRegistry = new Registry<Class>(c => c.name);

src/double-indexed-kv.ts

@@ -0,0 +1,31 @@
+export class DoubleIndexedKV<K, V> {
+  keyToValue = new Map<K, V>();
+  valueToKey = new Map<V, K>();
+
+  set(key: K, value: V) {
+    this.keyToValue.set(key, value);
+    this.valueToKey.set(value, key);
+  }
+
+  deleteByValue(value: V) {
+    this.valueToKey.delete(value);
+    this.keyToValue.forEach((otherValue, otherKey) => {
+      if (value === otherValue) {
+        this.keyToValue.delete(otherKey);
+      }
+    });
+  }
+
+  getByKey(key: K): V | undefined {
+    return this.keyToValue.get(key);
+  }
+
+  getByValue(value: V): K | undefined {
+    return this.valueToKey.get(value);
+  }
+
+  clear() {
+    this.keyToValue.clear();
+    this.valueToKey.clear();
+  }
+}

src/index.test.ts

@@ -380,6 +380,30 @@ describe('stringify & parse', () => {
         expect(value.users.values().next().value).toBe(value.userOfTheMonth);
       },
     },
+
+    'works for symbols': {
+      input: () => {
+        const parent = Symbol('Parent');
+        const child = Symbol('Child');
+        SuperJSON.registerSymbol(parent, '1');
+        SuperJSON.registerSymbol(child, '2');
+
+        const a = { role: parent };
+        const b = { role: child };
+
+        return { a, b };
+      },
+      output: {
+        a: { role: 'Parent' },
+        b: { role: 'Child' },
+      },
+      outputAnnotations: {
+        values: {
+          'a.role': [['symbol', '1']],
+          'b.role': [['symbol', '2']],
+        },
+      },
+    },
   };
 
   function deepFreeze(object: any, alreadySeenObjects = new Set()) {
@@ -457,7 +481,7 @@ describe('stringify & parse', () => {
       SuperJSON.registerClass(Train);
 
       const { json, meta } = SuperJSON.serialize({
-        s7: new Train(100, 'yellow', 'Bombardier'),
+        s7: new Train(100, 'yellow', 'Bombardier') as any,
       });
 
       expect(json).toEqual({
@@ -494,7 +518,7 @@ describe('stringify & parse', () => {
         SuperJSON.registerClass(Currency);
 
         const { json, meta } = SuperJSON.serialize({
-          price: new Currency(100),
+          price: new Currency(100) as any,
         });
 
         expect(json).toEqual({

src/index.ts

@@ -1,8 +1,14 @@
 import { applyAnnotations, makeAnnotator } from './annotator';
 import { isEmptyObject } from './is';
 import { plainer } from './plainer';
-import { SuperJSONResult, SuperJSONValue, isSuperJSONResult } from './types';
-import { clear, registerClass, unregisterClass } from './class-registry';
+import {
+  SuperJSONResult,
+  SuperJSONValue,
+  isSuperJSONResult,
+  Class,
+} from './types';
+import { ClassRegistry } from './class-registry';
+import { SymbolRegistry } from './symbol-registry';
 
 const serialize = (object: SuperJSONValue): SuperJSONResult => {
   const { getAnnotations, annotator } = makeAnnotator();
@@ -38,12 +44,21 @@ const stringify = (object: SuperJSONValue): string =>
 export const parse = <T = unknown>(string: string): T =>
   deserialize(JSON.parse(string));
 
+const registerClass = (v: Class, identifier?: string) =>
+  ClassRegistry.register(v, identifier);
+const unregisterClass = (v: Class) => ClassRegistry.unregister(v);
+
+const registerSymbol = (v: Symbol, identifier?: string) =>
+  SymbolRegistry.register(v, identifier);
+const unregisterSymbol = (v: Symbol) => SymbolRegistry.unregister(v);
+
 export default {
   stringify,
   parse,
   serialize,
   deserialize,
-  clear,
   registerClass,
   unregisterClass,
+  registerSymbol,
+  unregisterSymbol,
 };

src/registry.test.ts

@@ -0,0 +1,38 @@
+import { Registry } from './registry';
+import { Class } from './types';
+
+test('class registry', () => {
+  const registry = new Registry<Class>(c => c.name);
+
+  class Car {
+    honk() {
+      console.log('honk');
+    }
+  }
+  registry.register(Car);
+
+  expect(registry.getValue('Car')).toBe(Car);
+  expect(registry.getIdentifier(Car)).toBe('Car');
+
+  expect(() => registry.register(Car)).not.toThrow();
+
+  expect(() => registry.register(class Car {})).toThrow(
+    'Ambiguous class, provide a unique identifier.'
+  );
+
+  registry.unregister(Car);
+
+  expect(registry.getValue('Car')).toBeUndefined();
+
+  registry.register(Car, 'car1');
+
+  registry.register(class Car {}, 'car2');
+
+  expect(registry.getValue('car1')).toBe(Car);
+
+  expect(registry.getValue('car2')).not.toBeUndefined();
+
+  registry.clear();
+
+  expect(registry.getValue('car1')).toBeUndefined();
+});

src/registry.ts

@@ -0,0 +1,39 @@
+import { DoubleIndexedKV } from './double-indexed-kv';
+
+export class Registry<T> {
+  private kv = new DoubleIndexedKV<string, T>();
+
+  constructor(private readonly generateIdentifier: (v: T) => string) {}
+
+  register(value: T, identifier?: string): void {
+    if (this.kv.getByValue(value)) {
+      return;
+    }
+
+    if (!identifier) {
+      identifier = this.generateIdentifier(value);
+    }
+
+    if (this.kv.getByKey(identifier)) {
+      throw new Error('Ambiguous class, provide a unique identifier.');
+    }
+
+    this.kv.set(identifier, value);
+  }
+
+  unregister(v: T): void {
+    this.kv.deleteByValue(v);
+  }
+
+  clear(): void {
+    this.kv.clear();
+  }
+
+  getIdentifier(value: T) {
+    return this.kv.getByValue(value);
+  }
+
+  getValue(identifier: string) {
+    return this.kv.getByKey(identifier);
+  }
+}

src/symbol-registry.ts

@@ -0,0 +1,3 @@
+import { Registry } from './registry';
+
+export const SymbolRegistry = new Registry<Symbol>(s => s.description ?? '');

src/transformer.ts

@@ -7,17 +7,24 @@ import {
   isRegExp,
   isSet,
   isUndefined,
+  isSymbol,
 } from './is';
-import * as ClassRegistry from './class-registry';
+import { ClassRegistry } from './class-registry';
+import { SymbolRegistry } from './symbol-registry';
 import * as IteratorUtils from './iteratorutils';
 
 export type PrimitiveTypeAnnotation = 'number' | 'undefined' | 'bigint';
 
 type LeafTypeAnnotation = PrimitiveTypeAnnotation | 'regexp' | 'Date';
 
 type ClassTypeAnnotation = ['class', string];
+type SymbolTypeAnnotation = ['symbol', string];
 
-type ContainerTypeAnnotation = 'map' | 'set' | ClassTypeAnnotation;
+type ContainerTypeAnnotation =
+  | 'map'
+  | 'set'
+  | ClassTypeAnnotation
+  | SymbolTypeAnnotation;
 
 export type TypeAnnotation = LeafTypeAnnotation | ContainerTypeAnnotation;
 
@@ -42,6 +49,7 @@ export const isTypeAnnotation = (value: any): value is TypeAnnotation => {
     switch (value[0]) {
       case 'map':
         return ['number', 'string', 'bigint', 'boolean'].includes(value[1]);
+      case 'symbol':
       case 'class':
         return typeof value[1] === 'string';
     }
@@ -58,6 +66,14 @@ export const transformValue = (
       value: undefined,
       type: 'undefined',
     };
+  } else if (isSymbol(value)) {
+    const identifier = SymbolRegistry.getIdentifier(value);
+    if (identifier) {
+      return {
+        value: value.description,
+        type: ['symbol', identifier],
+      };
+    }
   } else if (isBigint(value)) {
     return {
       value: value.toString(),
@@ -113,14 +129,24 @@ export const untransformValue = (json: any, type: TypeAnnotation) => {
   if (Array.isArray(type)) {
     switch (type[0]) {
       case 'class': {
-        const clazz = ClassRegistry.getClass(type[1]);
+        const clazz = ClassRegistry.getValue(type[1]);
 
         if (!clazz) {
           throw new Error('Trying to deserialize unknown class');
         }
 
         return Object.assign(Object.create(clazz.prototype), json);
       }
+
+      case 'symbol': {
+        const symbol = SymbolRegistry.getValue(type[1]);
+
+        if (!symbol) {
+          throw new Error('Trying to deserialize unknown symbol');
+        }
+
+        return symbol;
+      }
     }
   }
 

src/types.ts

@@ -16,6 +16,7 @@ export interface JSONObject {
 type ClassInstance = any;
 
 export type SerializableJSONValue =
+  | Symbol
   | Set<SuperJSONValue>
   | Map<SuperJSONValue, SuperJSONValue>
   | undefined