seriall 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,7 +1,9 @@
 // src/const/const.ts
-var SIGNATURE_KEY = "$";
-var DATA_KEY = "d";
+var SIGNATURE_INDEX = 0;
+var DATA_INDEX = 1;
 var NO_TRANSFORM_DATA = void 0;
+var PROTOCOL_VERSION = 1;
+var LIB = "seriall";
 var PRIORITY = {
   CUSTOM_CLASS: 0,
   NATIVE_CLASS: 1,
@@ -14,13 +16,13 @@ var isSpecialNumber = (value) => {
   return [Infinity, -Infinity, NaN].includes(value) || Object.is(value, -0);
 };
 var encodeSpecialNumber = (value) => {
-  if (Number.isNaN(value)) return 0;
-  if (value === Infinity) return 1;
-  if (value === -Infinity) return 2;
-  if (Object.is(value, -0)) return 3;
+  if (Number.isNaN(value)) return [0];
+  if (value === Infinity) return [1];
+  if (value === -Infinity) return [2];
+  if (Object.is(value, -0)) return [3];
   throw new Error(value + " is not a special number");
 };
-var decodeSpecialNumber = (value) => {
+var decodeSpecialNumber = ([value]) => {
   switch (value) {
     case 0:
       return NaN;
@@ -40,7 +42,7 @@ var isJsonPrimitive = (value) => {
   if (typeof value === "number") {
     return !isSpecialNumber(value);
   }
-  return typeof value === "string" || typeof value === "boolean";
+  return typeof value === "string" || typeof value === "boolean" || value === null;
 };
 
 // src/utils/object.utils.ts
@@ -68,27 +70,30 @@ var serialize = (data, transformers) => {
   const graph = [];
   const seen = /* @__PURE__ */ new Map();
   const addNodeToGraph = (node) => {
-    if (isJsonPrimitive(node)) {
-      const id2 = graph.length;
-      graph.push(node);
-      return id2;
-    }
     let id = seen.get(node);
-    if (id !== void 0) {
+    if (id !== void 0 && !Object.is(node, -0)) {
       return id;
     }
     id = graph.length;
     seen.set(node, id);
+    if (isJsonPrimitive(node)) {
+      const id2 = graph.length;
+      graph.push(node);
+      return id2;
+    }
     const transformer = transformers.find(
       (transformer2) => transformer2.match(node)
     );
     if (transformer) {
-      graph.push({ $: transformer.id });
+      graph.push([]);
       const revivable = graph[id];
+      revivable[SIGNATURE_INDEX] = transformer.id;
       const encoded = transformer.encode(node);
       if (encoded !== NO_TRANSFORM_DATA) {
-        const dataId = addNodeToGraph(encoded);
-        revivable.d = dataId;
+        encoded.forEach((el, index) => {
+          const dataId = addNodeToGraph(el);
+          revivable[DATA_INDEX + index] = dataId;
+        });
       }
       return id;
     }
@@ -101,21 +106,49 @@ var serialize = (data, transformers) => {
       }
       return id;
     }
+    if (typeof node === "object") {
+      graph.push({});
+      const obj = graph[id];
+      for (const key in node) {
+        const elementId = addNodeToGraph(node[key]);
+        obj[key] = elementId;
+      }
+      return id;
+    }
     throw new Error(
       `No transformer found for the current value "${node?.toString()}", please add one`
     );
   };
   addNodeToGraph(data);
-  return JSON.stringify(graph);
+  const serialized = {
+    lib: LIB,
+    v: PROTOCOL_VERSION,
+    d: graph
+  };
+  return JSON.stringify(serialized);
 };
 
 // src/serialization/deserialize.ts
 var deserialize = (data, transformers) => {
-  const graph = JSON.parse(data);
-  const revived = /* @__PURE__ */ new Map();
+  const { lib, v, d } = JSON.parse(data);
+  if (lib !== LIB) {
+    throw new Error(
+      `Can't deserialize data, invalid lib metadata. Expected "${LIB}", got "${lib}"`
+    );
+  }
+  if (v !== PROTOCOL_VERSION) {
+    throw new Error(
+      `Can't deserialize data, invalid protocol version. Expected ${PROTOCOL_VERSION}, got ${v}`
+    );
+  }
+  if (!Array.isArray(d)) {
+    throw new Error("Invalid seriall payload: 'd' must be an array");
+  }
+  const graph = d;
+  const revived = [];
   const reviveNode = (index) => {
-    if (revived.has(index)) {
-      return revived.get(index);
+    if (index in revived) {
+      return revived[index];
     }
     if (graph.length <= index || index < 0) {
       throw new Error(`Invalid serialized graph reference: ${index}`);
@@ -124,37 +157,54 @@ var deserialize = (data, transformers) => {
     if (isJsonPrimitive(node)) {
       return node;
     }
-    if (Array.isArray(node)) {
+    if (!Array.isArray(node) && typeof node === "object") {
+      const obj = {};
+      revived[index] = obj;
+      for (const key of Object.keys(node)) {
+        obj[key] = reviveNode(node[key]);
+      }
+      return obj;
+    }
+    if (typeof node[SIGNATURE_INDEX] !== "string") {
+      const typedNode2 = node;
       const arr = [];
-      revived.set(index, arr);
-      for (const element of node) {
+      revived[index] = arr;
+      for (const element of typedNode2) {
         arr.push(reviveNode(element));
       }
       return arr;
     }
-    const transformerId = node[SIGNATURE_KEY];
-    const transformer = transformers.get(transformerId);
+    const typedNode = node;
+    const transformerId = typedNode[SIGNATURE_INDEX];
+    const transformer = transformers[transformerId];
     if (!transformerId) {
-      throw new Error(`No transformer found for node "${node}"`);
+      throw new Error(`No transformer found for node "${typedNode}"`);
     }
     if (transformer === void 0) {
       throw new Error(`No transformer found with id "${transformerId}"`);
     }
     const nonRecursiveTransformer = transformer;
-    const dataId = node[DATA_KEY];
-    if (dataId === void 0) {
+    if (!transformer.recursive && typedNode[DATA_INDEX] === void 0) {
       const decoded = nonRecursiveTransformer.decode(NO_TRANSFORM_DATA);
-      revived.set(index, decoded);
+      revived[index] = decoded;
       return decoded;
     }
     if (!transformer.recursive) {
-      const decoded = nonRecursiveTransformer.decode(reviveNode(dataId));
-      revived.set(index, decoded);
+      const revivedValues = new Array(typedNode.length - 1);
+      for (let i = 1; i < typedNode.length; i++) {
+        revivedValues[i - 1] = reviveNode(typedNode[i]);
+      }
+      const decoded = nonRecursiveTransformer.decode(revivedValues);
+      revived[index] = decoded;
       return decoded;
     }
     const registerNode = (node2) => {
-      revived.set(index, node2);
-      return reviveNode(dataId);
+      revived[index] = node2;
+      const revivedValues = new Array(typedNode.length - 1);
+      for (let i = 1; i < typedNode.length; i++) {
+        revivedValues[i - 1] = reviveNode(typedNode[i]);
+      }
+      return revivedValues;
     };
     return transformer.decode(registerNode);
   };
@@ -193,15 +243,15 @@ var primitivesTransformers = [
     id: "sym",
     priority: Transformer.PRIORITY.PRIMITIVE,
     match: (node) => typeof node === "symbol",
-    encode: (node) => ({
-      d: node.description,
-      f: Symbol.keyFor(node) === void 0 ? 0 : 1
-    }),
+    encode: (node) => [
+      node.description,
+      Symbol.keyFor(node) === void 0 ? 0 : 1
+    ],
     decode: (encoded) => {
-      if (encoded.f === 1 && encoded.d) {
+      if (encoded[1] === 1) {
         return Symbol.for(encoded.d);
       }
-      return Symbol(encoded.d);
+      return Symbol(encoded[0]);
     }
   }),
   new Transformer({
@@ -218,49 +268,45 @@ var primitivesTransformers = [
     encode: () => NO_TRANSFORM_DATA,
     decode: () => void 0
   }),
-  new Transformer({
-    id: "nul",
-    priority: Transformer.PRIORITY.PRIMITIVE,
-    match: (node) => node === null,
-    encode: () => NO_TRANSFORM_DATA,
-    decode: () => null
-  }),
   new Transformer({
     id: "big",
     priority: Transformer.PRIORITY.PRIMITIVE,
     match: (node) => typeof node === "bigint",
-    encode: (node) => node.toString(),
-    decode: (node) => BigInt(node)
-  }),
-  new Transformer({
-    id: "obj",
-    priority: Transformer.PRIORITY.PRIMITIVE,
-    recursive: true,
-    match: (node) => !Array.isArray(node) && typeof node === "object",
-    encode: (node) => {
-      const obj = [];
-      for (const key of Reflect.ownKeys(node)) {
+    encode: (node) => [node.toString()],
+    decode: ([node]) => BigInt(node)
+  })
+];
+var objectSymbolIndexingTransformer = new Transformer({
+  id: "obj",
+  priority: Transformer.PRIORITY.PRIMITIVE,
+  recursive: true,
+  match: (node) => !Array.isArray(node) && typeof node === "object",
+  encode: (node) => {
+    const obj = [];
+    for (const key of Reflect.ownKeys(node)) {
+      const value = node[key];
+      if (typeof value !== "function") {
         obj.push([key, node[key]]);
       }
-      return obj;
-    },
-    decode: (registerNode) => {
-      const obj = {};
-      const encoded = registerNode(obj);
-      for (const [key, value] of encoded) {
-        obj[key] = value;
-      }
-      return obj;
     }
-  })
-];
+    return obj;
+  },
+  decode: (registerNode) => {
+    const obj = {};
+    const encoded = registerNode(obj);
+    for (const [key, value] of encoded) {
+      obj[key] = value;
+    }
+    return obj;
+  }
+});
 var nativeClassesTransformers = [
   new Transformer({
     id: "Dte",
     priority: Transformer.PRIORITY.NATIVE_CLASS,
     match: (node) => node instanceof Date,
-    encode: (node) => node.getTime(),
-    decode: (node) => new Date(node)
+    encode: (node) => [node.getTime()],
+    decode: ([node]) => new Date(node)
   }),
   new Transformer({
     id: "Set",
@@ -296,29 +342,29 @@ var nativeClassesTransformers = [
     id: "Rgx",
     priority: Transformer.PRIORITY.NATIVE_CLASS,
     match: (node) => node instanceof RegExp,
-    encode: (node) => ({ s: node.source, f: node.flags }),
-    decode: (node) => new RegExp(node.s, node.f)
+    encode: (node) => [node.source, node.flags],
+    decode: (node) => new RegExp(node[0], node[1])
   }),
   new Transformer({
     id: "Str",
     priority: Transformer.PRIORITY.NATIVE_CLASS,
     match: (node) => node instanceof String,
-    encode: (node) => node.valueOf(),
-    decode: (node) => new String(node)
+    encode: (node) => [node.valueOf()],
+    decode: ([node]) => new String(node)
   }),
   new Transformer({
     id: "Num",
     priority: Transformer.PRIORITY.NATIVE_CLASS,
     match: (node) => node instanceof Number,
-    encode: (node) => node.valueOf(),
-    decode: (node) => new Number(node)
+    encode: (node) => [node.valueOf()],
+    decode: ([node]) => new Number(node)
   }),
   new Transformer({
     id: "Bol",
     priority: Transformer.PRIORITY.NATIVE_CLASS,
     match: (node) => node instanceof Boolean,
-    encode: (node) => node.valueOf(),
-    decode: (node) => new Boolean(node)
+    encode: (node) => [node.valueOf()],
+    decode: ([node]) => new Boolean(node)
   })
 ];
 
@@ -329,20 +375,21 @@ var SYMBOLS = { ENCODE, DECODE };
 var SerializableClass = class {
   constructor(..._) {
   }
-  [ENCODE] = () => {
-    const encoded = {};
-    for (const key of Reflect.ownKeys(this)) {
+  [ENCODE]() {
+    const encoded = [];
+    for (const key of Object.keys(this)) {
       const value = this[key];
       if (typeof value !== "function") {
-        encoded[key] = this[key];
+        encoded.push(this[key]);
       }
     }
     return encoded;
-  };
+  }
   static [DECODE] = function(registerNode) {
     let revivedInstance = {};
     const args = registerNode(revivedInstance);
-    Object.assign(revivedInstance, args);
+    const keys = Reflect.ownKeys(new this({}));
+    keys.forEach((key, index) => revivedInstance[key] = args[index]);
     Object.setPrototypeOf(revivedInstance, this.prototype);
     return revivedInstance;
   };
@@ -361,23 +408,30 @@ var defaultOptions = {
   enable: {
     builtinPrimitiveTransformers: true,
     builtinNativeClasses: true,
-    builtinClassTransformer: true
-  }
+    objectSymbolIndexing: false
+  },
+  classes: {}
 };
 var Serializer = class {
   transformers = [];
-  transformersMap = /* @__PURE__ */ new Map();
+  transformersRecord = {};
   constructor(options = {}) {
     const opt = deepMerge(defaultOptions, options);
     if (opt.enable.builtinPrimitiveTransformers)
       primitivesTransformers.forEach(this.registerTransformer);
     if (opt.enable.builtinNativeClasses)
       nativeClassesTransformers.forEach(this.registerTransformer);
+    if (opt.enable.objectSymbolIndexing) {
+      this.registerTransformer(objectSymbolIndexingTransformer);
+    }
+    for (const className in opt.classes) {
+      this.registerClass(className, opt.classes[className]);
+    }
   }
   serialize = (data) => serialize(data, this.transformers);
-  deserialize = (data) => deserialize(data, this.transformersMap);
+  deserialize = (data) => deserialize(data, this.transformersRecord);
   registerTransformer = (transformer) => {
-    if (this.transformersMap.has(transformer.id)) {
+    if (transformer.id in this.transformersRecord) {
       throw new Error(
         `A transformer with id "${transformer.id}" is already registered, chose another one`
       );
@@ -386,11 +440,11 @@ var Serializer = class {
     this.transformers = this.transformers.sort(
       (a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity)
     );
-    this.transformersMap.set(transformer.id, transformer);
+    this.transformersRecord[transformer.id] = transformer;
   };
   deregisterTransformer = (transformer) => {
     const id = typeof transformer === "object" ? transformer.id : transformer;
-    if (!this.transformersMap.has(id)) {
+    if (!(id in this.transformersRecord)) {
       throw new Error(
         `No transformer found for id "${id}", cannot deregister it`
       );
@@ -398,7 +452,7 @@ var Serializer = class {
     this.transformers = this.transformers.filter(
       (transformer2) => transformer2.id !== id
     );
-    this.transformersMap.delete(id);
+    delete this.transformersRecord[id];
   };
   registerClass = (name, clazz) => {
     this.registerTransformer(createClassTransformer("$" + name, clazz));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seriall",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A flexible js serializer, capable of serializing/deserializing any js data, while preserving referential integrity, non-json-primitive values, and even custom class instances",
   "author": {
     "email": "loic.duvail.pro@gmail.com",
@@ -25,7 +25,9 @@
     "build:js": "node ./esbuild.js",
     "build:types": "rollup -c",
     "build:test": "node ./esbuild.test.js",
-    "test": "npm run build:test && npx jest"
+    "build:benchmark": "node ./esbuild.benchmark.js",
+    "test": "npm run build:test && npx jest",
+    "bench": "npm run build:benchmark && node benchmark/benchmark.js /"
   },
   "keywords": [
     "serializer",
@@ -43,10 +45,13 @@
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/node": "^26.5.1",
+    "devalue": "^6.0.2",
     "esbuild": "^0.28.2",
+    "flatted": "^3.4.4",
     "jest": "^30.5.1",
     "rollup": "^4.63.6",
     "rollup-plugin-dts": "^6.5.1",
+    "superjson": "^2.2.6",
     "typescript": "^6.0.3"
   }
 }