json-as 1.0.8 → 1.0.9

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 2025-05-22 - 1.0.9
+
+- fix: [#132](https://github.com/JairusSW/json-as/issues/132)
+- feat: allow base classes to use their child classes if the signatures match
+- perf: rewrite struct deserialization to be significantly faster
+- fix: [#131](https://github.com/JairusSW/json-as/issues/131) Generic classes with custom deserializer crashing
+- fix: [#66](https://github.com/JairusSW/json-as/issues/66) Throw error when additional keys are in JSON
+
 ## 2025-05-21 - 1.0.8
 
 - fix: inline warnings on layer-2 serialize and deserialize functions

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.8
+    AssemblyScript - v1.0.9
   </pre>
 </h6>
 
@@ -57,6 +57,7 @@ If you'd like to see the code that the transform generates, run the build step w
 ```typescript
 import { JSON } from "json-as";
 
+
 @json
 class Vec3 {
   x: f32 = 0.0;
@@ -64,8 +65,10 @@ class Vec3 {
   z: f32 = 0.0;
 }
 
+
 @json
 class Player {
+
   @alias("first name")
   firstName!: string;
   lastName!: string;
@@ -73,6 +76,7 @@ class Player {
   // Drop in a code block, function, or expression that evaluates to a boolean
   @omitif((self: Player) => self.age < 18)
   age!: i32;
+
   @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
@@ -109,9 +113,11 @@ This library allows selective omission of fields during serialization using the
 This decorator excludes a field from serialization entirely.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omit
   SSN!: string;
 }
@@ -128,9 +134,11 @@ console.log(JSON.stringify(obj)); // { "name": "Jairus" }
 This decorator omits a field only if its value is null.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omitnull()
   optionalField!: string | null;
 }
@@ -147,9 +155,11 @@ console.log(JSON.stringify(obj)); // { "name": "Jairus" }
 This decorator omits a field based on a custom predicate function.
 
 ```typescript
+
 @json
 class Example {
   name!: string;
+
   @omitif((self: Example) => self.age <= 18)
   age!: number;
 }
@@ -174,6 +184,7 @@ AssemblyScript doesn't support using nullable primitive types, so instead, json-
 For example, this schema won't compile in AssemblyScript:
 
 ```typescript
+
 @json
 class Person {
   name!: string;
@@ -184,6 +195,7 @@ class Person {
 Instead, use `JSON.Box` to allow nullable primitives:
 
 ```typescript
+
 @json
 class Person {
   name: string;
@@ -246,6 +258,7 @@ More often, objects will be completely statically typed except for one or two va
 In such cases, `JSON.Value` can be used to handle fields that may hold different types at runtime.
 
 ```typescript
+
 @json
 class DynamicObj {
   id: i32 = 0;
@@ -302,6 +315,7 @@ Here's an example of creating a custom data type called `Point` which serializes
 ```typescript
 import { bytes } from "json-as/assembly/util";
 
+
 @json
 class Point {
   x: f64 = 0.0;
@@ -311,11 +325,13 @@ class Point {
     this.y = y;
   }
 
+
   @serializer
   serializer(self: Point): string {
     return `(${self.x},${self.y})`;
   }
 
+
   @deserializer
   deserializer(data: string): Point {
     const dataSize = bytes(data);

package/assembly/__benches__/lib/bench.ts

@@ -1,6 +1,6 @@
 export function bench(description: string, routine: () => void, ops: u64 = 1_000_000): void {
   console.log(" - Benchmarking " + description);
-  let warmup = ops/10;
+  let warmup = ops / 10;
   while (--warmup) {
     routine();
   }

package/assembly/__benches__/vec3.bench.ts

@@ -7,52 +7,6 @@ class Vec3 {
   public x!: i32;
   public y!: i32;
   public z!: i32;
-
-
-  @inline __SERIALIZE(ptr: usize): void {
-    bs.proposeSize(98);
-    store<u64>(bs.offset, 9570664606466171, 0); // {"x"
-    store<u16>(bs.offset, 58, 8); // :
-    bs.offset += 10;
-    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("x")));
-    store<u64>(bs.offset, 9570668901433388, 0); // ,"y"
-    store<u16>(bs.offset, 58, 8); // :
-    bs.offset += 10;
-    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("y")));
-    store<u64>(bs.offset, 9570673196400684, 0); // ,"z"
-    store<u16>(bs.offset, 58, 8); // :
-    bs.offset += 10;
-    JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("z")));
-    store<u16>(bs.offset, 125, 0); // }
-    bs.offset += 2;
-  }
-
-
-  @inline __INITIALIZE(): this {
-    return this;
-  }
-
-
-  @inline __DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {
-    switch (load<u16>(keyStart)) {
-      case 120: {
-        // x
-        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("x"));
-        return;
-      }
-      case 121: {
-        // y
-        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("y"));
-        return;
-      }
-      case 122: {
-        // z
-        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("z"));
-        return;
-      }
-    }
-    return;
-  }
 }
 
 const v1: Vec3 = { x: 1, y: 2, z: 3 };

package/assembly/__tests__/custom.spec.ts

@@ -32,11 +32,12 @@ class Point {
   }
 }
 
+
 @json
-export class ObjectWithCustom {
-  value: Point = new Point(0, 0)
+class ObjectWithCustom {
+  value: Point = new Point(0, 0);
   constructor(value: Point) {
-    this.value = value
+    this.value = value;
   }
 }
 

package/assembly/__tests__/hierarchy.spec.ts

@@ -0,0 +1,55 @@
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+@json
+class Foo {
+  a: i32 = 0;
+}
+
+@json
+class Bar extends Foo {
+  b: i32 = 0;
+
+  @serializer
+  serialize(self: Bar): string {
+    return `"bar"`;
+  }
+
+  @deserializer
+  deserialize(data: string): Bar {
+    return data == "\"bar\"" ? {
+      a: 1,
+      b: 2,
+    } : new Bar();
+  }
+}
+
+describe("should use custom serializer for subclasses", () => {
+  const bar = new Bar();
+  bar.a = 1;
+  bar.b = 2;
+  const data = JSON.stringify(bar);
+  expect(data).toBe('"bar"');
+});
+
+describe("should use custom serializer for subclasses when type is the parent", () => {
+  const bar = new Bar();
+  bar.a = 1;
+  bar.b = 2;
+  const data = JSON.stringify<Foo>(bar);
+  expect(data).toBe('"bar"');
+});
+
+describe("should use custom deserializer for subclass", () => {
+  const json = '"bar"';
+  const bar = JSON.parse<Bar>(json);
+  expect(bar.a.toString()).toBe("1");
+  expect(bar.b.toString()).toBe("2");
+});
+
+describe("should use custom deserializer even when type is the parent", () => {
+  const json = '"bar"';
+  const foo = JSON.parse<Bar>(json);
+  expect(foo.a.toString()).toBe("1");
+});

package/assembly/__tests__/lib/index.ts

@@ -1,5 +1,6 @@
 export function describe(description: string, routine: () => void): void {
   routine();
+  // console.log("  " + description + " OK");
 }
 
 export function expect(left: string): Expectation {

package/assembly/deserialize/simple/array/box.ts

@@ -3,43 +3,43 @@ import { COMMA, BRACKET_RIGHT } from "../../../custom/chars";
 import { JSON } from "../../..";
 
 export function deserializeBoxArray<T extends JSON.Box<any>[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
-    const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
-    if (isBoolean<valueof<T>>()) {
-        srcStart += 2; // skip [
-        while (srcStart < srcEnd) {
-            const block = load<u64>(srcStart);
-            if (block == 28429475166421108) {
-                out.push(JSON.Box.from(true));
-                srcStart += 10;
-            } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
-                out.push(JSON.Box.from(false));
-                srcStart += 12;
-            } else {
-                srcStart += 2;
-            }
-        }
-        return out;
-    } else {
-        let lastIndex: usize = 0;
+  const out = changetype<nonnull<T>>(dst || changetype<usize>(instantiate<T>()));
+  if (isBoolean<valueof<T>>()) {
+    srcStart += 2; // skip [
+    while (srcStart < srcEnd) {
+      const block = load<u64>(srcStart);
+      if (block == 28429475166421108) {
+        out.push(JSON.Box.from(true));
+        srcStart += 10;
+      } else if (block == 32370086184550502 && load<u16>(srcStart, 8) == 101) {
+        out.push(JSON.Box.from(false));
+        srcStart += 12;
+      } else {
+        srcStart += 2;
+      }
+    }
+    return out;
+  } else {
+    let lastIndex: usize = 0;
+    while (srcStart < srcEnd) {
+      const code = load<u16>(srcStart);
+      if (code - 48 <= 9 || code == 45) {
+        lastIndex = srcStart;
+        srcStart += 2;
         while (srcStart < srcEnd) {
-            const code = load<u16>(srcStart);
-            if (code - 48 <= 9 || code == 45) {
-                lastIndex = srcStart;
-                srcStart += 2;
-                while (srcStart < srcEnd) {
-                    const code = load<u16>(srcStart);
-                    if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
-                        out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
-                        // while (isSpace(load<u16>((srcStart += 2)))) {
-                        //   /* empty */
-                        // }
-                        break;
-                    }
-                    srcStart += 2;
-                }
-            }
-            srcStart += 2;
+          const code = load<u16>(srcStart);
+          if (code == COMMA || code == BRACKET_RIGHT || isSpace(code)) {
+            out.push(JSON.__deserialize<valueof<T>>(lastIndex, srcStart));
+            // while (isSpace(load<u16>((srcStart += 2)))) {
+            //   /* empty */
+            // }
+            break;
+          }
+          srcStart += 2;
         }
+      }
+      srcStart += 2;
     }
-    return out;
+  }
+  return out;
 }

package/assembly/deserialize/simple/array.ts

@@ -37,7 +37,7 @@ export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: u
     } else if (type instanceof JSON.Obj) {
       // @ts-ignore: type
       return deserializeObjectArray<T>(srcStart, srcEnd, dst);
-    }else if (type instanceof Map) {
+    } else if (type instanceof Map) {
       // @ts-ignore: type
       return deserializeMapArray<T>(srcStart, srcEnd, dst);
       // @ts-ignore: defined by transform

package/assembly/index.ts

@@ -28,9 +28,6 @@ import { serializeObject } from "./serialize/simple/object";
 import { deserializeObject } from "./deserialize/simple/object";
 import { serializeRaw } from "./serialize/simple/raw";
 import { deserializeRaw } from "./deserialize/simple/raw";
-import { isSpace } from "util/string";
-import { deserializeString_SIMD } from "./deserialize/simd/string";
-import { serializeString_SIMD } from "./serialize/simd/string";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -119,15 +116,10 @@ export namespace JSON {
       // if (ASC_FEATURE_SIMD) {
       //   serializeString_SIMD(data as string);
       // } else {
-        serializeString(data as string);
+      serializeString(data as string);
       // }
       return bs.out<string>();
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
-      // @ts-ignore
-      inline.always(data.__SERIALIZE_CUSTOM());
-      return bs.out<string>();
-      // @ts-ignore: Supplied by transform
     } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
       inline.always(data.__SERIALIZE(changetype<usize>(data)));
@@ -200,19 +192,12 @@ export namespace JSON {
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-ignore: Defined by transform
-      if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-        const out = changetype<nonnull<T>>(0);
+      if (isDefined(type.__DESERIALIZE)) {
+        const out = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-ignore: Defined by transform
         if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-ignore
-        return out.__DESERIALIZE_CUSTOM(ptrToStr(dataPtr, dataPtr + dataSize));
-        // @ts-ignore: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
-        const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
-        // @ts-ignore: Defined by transform
-        if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
-        // @ts-ignore
-        return inline.always(deserializeStruct<nonnull<T>>(dataPtr, dataPtr + dataSize, out));
+        return out.__DESERIALIZE(dataPtr, dataPtr + dataSize, out);
       } else if (type instanceof Map) {
         // @ts-ignore
         return inline.always(deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0));
@@ -408,7 +393,7 @@ export namespace JSON {
         case JSON.Types.Array: {
           const arr = this.get<JSON.Value[]>();
           if (!arr.length) return "[]";
-          let out = "["
+          let out = "[";
           const end = arr.length - 1;
           for (let i = 0; i < end; i++) {
             const element = unchecked(arr[i]);
@@ -440,7 +425,7 @@ export namespace JSON {
     // @ts-ignore: type
     private storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
 
-    constructor() { }
+    constructor() {}
 
     // @ts-ignore: decorator
     @inline get size(): i32 {
@@ -602,15 +587,10 @@ export namespace JSON {
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
       // @ts-ignore: Defined by transform
-      if (isDefined(type.__DESERIALIZE_CUSTOM)) {
-        const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
-        // @ts-ignore: Defined by transform
-        if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
-        // @ts-ignore
-        return changetype<nonnull<T>>(out).__DESERIALIZE_CUSTOM(ptrToStr(srcStart, srcEnd));
+      if (isDefined(type.__DESERIALIZE)) {
+        const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()))
         // @ts-ignore: Defined by transform
-      } else if (isDefined(type.__DESERIALIZE)) {
-        return deserializeStruct<T>(srcStart, srcEnd, dst);
+        return out.__DESERIALIZE(srcStart, srcEnd, out);
       } else if (type instanceof Map) {
         // @ts-ignore: type
         return deserializeMap<T>(srcStart, srcEnd, dst);
@@ -623,7 +603,7 @@ export namespace JSON {
       } else if (type instanceof JSON.Value) {
         // @ts-ignore: type
         return deserializeArbitrary(srcStart, srcEnd, 0);
-      }else if (type instanceof JSON.Obj) {
+      } else if (type instanceof JSON.Obj) {
         // @ts-ignore: type
         return deserializeObject(srcStart, srcEnd, 0);
       } else if (type instanceof JSON.Box) {
@@ -633,6 +613,19 @@ export namespace JSON {
     }
     throw new Error(`Could not deserialize data '${ptrToStr(srcStart, srcEnd).slice(0, 100)}' to type. Make sure to add the correct decorators to classes.`);
   }
+  namespace Util {
+    // @ts-ignore: decorator
+    @inline export function isSpace(code: u16): boolean {
+      return code == 0x20 || code - 9 <= 4;
+    }
+    // @ts-ignore: decorator
+    @inline export function ptrToStr(start: usize, end: usize): string {
+      const size = end - start;
+      const out = __new(size, idof<string>());
+      memory.copy(out, start, size);
+      return changetype<string>(out);
+    }
+  }
 }
 
 // @ts-ignore: decorator