json-as 1.1.21 → 1.1.22

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## 2025-09-01 - 1.1.22
+
+- fix: Type aliases should work across files [#154](https://github.com/JairusSW/json-as/issues/154)
+
 ## 2025-08-14 - 1.1.21
 
 - fix: JSON.parse on classes with enums [#155](https://github.com/JairusSW/json-as/issues/155)

package/README.md

@@ -378,19 +378,6 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | Medium Object   | 494 bytes  | 2,395,210 ops/s       | 1,381,693 ops/s         | 1,183 MB/s           | 682.5 MB/s             |
 | Large Object    | 3374 bytes | 222,222 ops/s         | 117,233 ops/s           | 749.7 MB/s           | 395.5 MB/s             |
 
-**📌 Insights**
-
-- JSON-AS consistently outperforms JavaScript's native implementation.
-
-- **Serialization Speed:**
-
-  - JSON-AS achieves speeds up to `2,133 MB/s`, significantly faster than JavaScript's peak of `1,416 MB/s`.
-  - Large objects see the biggest improvement, with JSON-AS at `2,074 MB/s` vs. JavaScript’s `749.7 MB/s`.
-
-- **Deserialization Speed:**
-  - JSON-AS reaches `1,986 MB/s`, while JavaScript caps at `1,592 MB/s`.
-  - Small and medium objects see the most significant performance boost overall.
-
 ### 📈 Comparison to v0.9.x version
 
 **Table 1** - _v1.0.0_
@@ -413,12 +400,45 @@ These benchmarks compare this library to JavaScript's native `JSON.stringify` an
 | Medium Object   | 494 bytes  | 522,193 ops/s         | 508,582 ops/s           | 258.0 MB/s           | 251.2 MB/s             |
 | Large Object    | 3374 bytes | 51,229 ops/s          | 65,585 ops/s            | 172.8 MB/s           | 221.3 MB/s             |
 
-**📌 Insights:**
+### Running benchmarks locally
+
+Benchmarks are run directly on top of v8 for more tailored control
+
+1. Download JSVU off of npm
+
+```bash
+npm install jsvu -g
+```
+
+2. Modify your dotfiles to add `~/.jsvu/bin` to `PATH`
+
+```bash
+export PATH="${HOME}/.jsvu/bin:${PATH}"
+```
+
+3. Clone the repository
 
-- Massive performance improvements in JSON-AS `v1.0.0`:
-- Serialization is **2-12x faster** (e.g., Large Object: `2,074 MB/s` vs. `172.8 MB/s`).
-- Deserialization is **2-3x faster** (e.g., Large Object: `1,348 MB/s` vs. `221.3 MB/s`).
-- Vector3 Object serialization improved from `416 MB/s` to `1,357 MB/s`--a **3x benefit** through new code generation techniques.
+```bash
+git clone https://github.com/JairusSW/json-as
+```
+
+4. Install dependencies
+
+```bash
+npm i
+```
+
+5. Run benchmarks for either AssemblyScript or JavaScript
+
+```bash
+./run-bench.as.sh
+```
+
+or
+
+```bash
+./run-bench.js.sh
+```
 
 ## 🔭 What's Next
 

package/assembly/index.ts

@@ -617,7 +617,7 @@ export namespace JSON {
       if (isDefined(type.__DESERIALIZE)) {
         const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-ignore: Defined by transform
-        if (isNullable<T>() && isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-ignore: Defined by transform
         return out.__DESERIALIZE(srcStart, srcEnd, out);
       } else if (type instanceof Map) {

package/assembly/test.tmp.ts

@@ -1,16 +1,303 @@
+import { bs } from "../lib/as-bs";
 import { JSON } from ".";
-const o = new JSON.Obj();
-o.set("schema", "http://json-schema.org/draft-07/schema#");
-o.set("additionalProperties", false);
-o.set("properties", new JSON.Obj());
-o.get("properties")!.as<JSON.Obj>().set("duration", new JSON.Obj());
-o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("default", 10);
-o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("description", "Duration of the operation in seconds");
-o.get("properties")!.as<JSON.Obj>().get("duration")!.as<JSON.Obj>().set("type", "number");
-o.get("properties")!.as<JSON.Obj>().set("steps", new JSON.Obj());
-o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("default", 5);
-o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("description", "Number of steps in the operation");
-o.get("properties")!.as<JSON.Obj>().get("steps")!.as<JSON.Obj>().set("type", "number");
-o.set("type", "object");
-console.log(o.toString());
-console.log((o.toString().length << 1).toString() + " == 596");
+
+@json
+class Example {
+  constructor(
+    public a: string,
+    public b: string,
+    public c: string,
+    public d: string,
+    public e: boolean,
+  ) {}
+  public f: string = "lol";
+  __SERIALIZE(ptr: usize): void {
+    bs.proposeSize(72);
+    store<u64>(bs.offset, 9570565822218363, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("a")));
+    store<u64>(bs.offset, 9570570117185580, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("b")));
+    store<u64>(bs.offset, 9570574412152876, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("c")));
+    store<u64>(bs.offset, 9570578707120172, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("d")));
+    store<u64>(bs.offset, 9570583002087468, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<boolean>(load<boolean>(ptr, offsetof<this>("e")));
+    store<u64>(bs.offset, 9570587297054764, 0);
+    store<u16>(bs.offset, 58, 8);
+    bs.offset += 10;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("f")));
+    store<u16>(bs.offset, 125, 0);
+    bs.offset += 2;
+  }
+
+  @inline
+  __INITIALIZE(): this {
+    store<string>(changetype<usize>(this), "", offsetof<this>("a"));
+    store<string>(changetype<usize>(this), "", offsetof<this>("b"));
+    store<string>(changetype<usize>(this), "", offsetof<this>("c"));
+    store<string>(changetype<usize>(this), "", offsetof<this>("d"));
+    store<string>(changetype<usize>(this), "lol", offsetof<this>("f"));
+    return this;
+  }
+  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
+    let keyStart: usize = 0;
+    let keyEnd: usize = 0;
+    let isKey = false;
+    let depth: i32 = 0;
+    let lastIndex: usize = 0;
+    while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;
+    while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+    if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
+    if (load<u16>(srcStart) != 123) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
+    if (load<u16>(srcEnd - 2) != 125) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+    srcStart += 2;
+    while (srcStart < srcEnd) {
+      let code = load<u16>(srcStart);
+      while (JSON.Util.isSpace(code)) code = load<u16>((srcStart += 2));
+      if (keyStart == 0) {
+        if (code == 34 && load<u16>(srcStart - 2) !== 92) {
+          if (isKey) {
+            keyStart = lastIndex;
+            keyEnd = srcStart;
+            console.log("Key: " + JSON.Util.ptrToStr(keyStart, keyEnd));
+            while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}
+            if (code !== 58) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
+            isKey = false;
+          } else {
+            isKey = true;
+            lastIndex = srcStart + 2;
+          }
+        }
+        srcStart += 2;
+      } else {
+        if (code == 34) {
+          lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34 && load<u16>(srcStart - 2) !== 92) {
+              console.log("Value (string, 1): " + JSON.Util.ptrToStr(lastIndex, srcStart + 2));
+              switch (<u32>keyEnd - <u32>keyStart) {
+                case 2: {
+                  const code16 = load<u16>(keyStart);
+                  if (code16 == 97) {
+                    store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("a"));
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 98) {
+                    store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("b"));
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 99) {
+                    store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("c"));
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 100) {
+                    store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("d"));
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  } else if (code16 == 102) {
+                    store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("f"));
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  } else {
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  }
+                }
+
+                default: {
+                  srcStart += 4;
+                  keyStart = 0;
+                  break;
+                }
+              }
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code - 48 <= 9 || code == 45) {
+          lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
+              console.log("Value (number, 2): " + JSON.Util.ptrToStr(lastIndex, srcStart));
+              srcStart += 2;
+              keyStart = 0;
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code == 123) {
+          lastIndex = srcStart;
+          depth++;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34) {
+              srcStart += 2;
+              while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
+            } else if (code == 125) {
+              if (--depth == 0) {
+                srcStart += 2;
+                console.log("Value (object, 3): " + JSON.Util.ptrToStr(lastIndex, srcStart));
+                switch (<u32>keyEnd - <u32>keyStart) {
+                  case 2: {
+                    const code16 = load<u16>(keyStart);
+                    if (code16 == 97) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("a"));
+                      keyStart = 0;
+                      break;
+                    } else if (code16 == 98) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("b"));
+                      keyStart = 0;
+                      break;
+                    } else if (code16 == 99) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("c"));
+                      keyStart = 0;
+                      break;
+                    } else if (code16 == 100) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("d"));
+                      keyStart = 0;
+                      break;
+                    } else if (code16 == 101) {
+                      store<boolean>(changetype<usize>(out), JSON.__deserialize<boolean>(lastIndex, srcStart), offsetof<this>("e"));
+                      keyStart = 0;
+                      break;
+                    } else if (code16 == 102) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart), offsetof<this>("f"));
+                      keyStart = 0;
+                      break;
+                    } else {
+                      keyStart = 0;
+                      break;
+                    }
+                  }
+
+                  default: {
+                    keyStart = 0;
+                    break;
+                  }
+                }
+                break;
+              }
+            } else if (code == 123) depth++;
+            srcStart += 2;
+          }
+        } else if (code == 91) {
+          lastIndex = srcStart;
+          depth++;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34) {
+              srcStart += 2;
+              while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
+            } else if (code == 93) {
+              if (--depth == 0) {
+                srcStart += 2;
+                console.log("Value (object, 4): " + JSON.Util.ptrToStr(lastIndex, srcStart));
+                keyStart = 0;
+                break;
+              }
+            } else if (code == 91) depth++;
+            srcStart += 2;
+          }
+        } else if (code == 116) {
+          if (load<u64>(srcStart) == 28429475166421108) {
+            srcStart += 8;
+            console.log("Value (bool, 5): " + JSON.Util.ptrToStr(lastIndex, srcStart - 8));
+            switch (<u32>keyEnd - <u32>keyStart) {
+              case 2: {
+                const code16 = load<u16>(keyStart);
+                if (code16 == 101) {
+                  store<boolean>(changetype<usize>(out), true, offsetof<this>("e"));
+                  srcStart += 2;
+                  keyStart = 0;
+                  break;
+                } else {
+                  srcStart += 2;
+                  keyStart = 0;
+                  break;
+                }
+              }
+
+              default: {
+                srcStart += 2;
+                keyStart = 0;
+              }
+            }
+          } else {
+            throw new Error("Expected to find 'true' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
+          }
+        } else if (code == 102) {
+          if (load<u64>(srcStart, 2) == 28429466576093281) {
+            srcStart += 10;
+            console.log("Value (bool, 6): " + JSON.Util.ptrToStr(lastIndex, srcStart - 10));
+            switch (<u32>keyEnd - <u32>keyStart) {
+              case 2: {
+                const code16 = load<u16>(keyStart);
+                if (code16 == 101) {
+                  store<boolean>(changetype<usize>(out), false, offsetof<this>("e"));
+                  srcStart += 2;
+                  keyStart = 0;
+                  break;
+                } else {
+                  srcStart += 2;
+                  keyStart = 0;
+                  break;
+                }
+              }
+
+              default: {
+                srcStart += 2;
+                keyStart = 0;
+              }
+            }
+          } else {
+            throw new Error("Expected to find 'false' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
+          }
+        } else if (code == 110) {
+          if (load<u64>(srcStart) == 30399761348886638) {
+            srcStart += 8;
+            console.log("Value (null, 7): " + JSON.Util.ptrToStr(lastIndex, srcStart - 8));
+            srcStart += 2;
+            keyStart = 0;
+          }
+        } else {
+          srcStart += 2;
+          keyStart = 0;
+        }
+      }
+    }
+    return out;
+  }
+}
+const good = `{"a":"a","b":"b","e":true,"c":"c","d":"d"}`;
+const good2 = `{"a":"a","b":"b","c":"c","d":"d","e":false}`;
+const bad = `{"a":"a","b":"b","e":false,"c":"c","d":"d"}`;
+const parsedGood = JSON.parse<Example>(good);
+console.log("a: " + JSON.stringify(parsedGood));
+const parsedGood2 = JSON.parse<Example>(good2);
+console.log("b: " + JSON.stringify(parsedGood2));
+const parsedBad = JSON.parse<Example>(bad);
+console.log("c: " + JSON.stringify(parsedBad));
+console.log(load<u64>(changetype<usize>("alse")).toString());

package/assembly/test.ts

@@ -2,43 +2,24 @@ import { JSON } from ".";
 
 
 @json
-class Vec3 {
-  x: f32 = 0.0;
-  y: f32 = 0.0;
-  z: f32 = 0.0;
+class Example {
+  constructor(
+    public a: string,
+    public b: string,
+    public c: string,
+    public d: string,
+    public e: boolean,
+  ) {}
 }
 
-
-@json
-class Player {
-
-  @alias("first name")
-  firstName!: string | null;
-  lastName!: string;
-  lastActive!: i32[];
-  // Drop in a code block, function, or expression that evaluates to a boolean
-  @omitif((self: Player) => self.age < 18)
-  age!: i32;
-
-  pos!: Vec3 | null;
-  isVerified!: boolean;
-}
-
-const player: Player = {
-  firstName: "Jairus",
-  lastName: "Tanaka",
-  lastActive: [3, 9, 2025],
-  age: 18,
-  pos: {
-    x: 3.4,
-    y: 1.2,
-    z: 8.3,
-  },
-  isVerified: true,
-};
-
-const serialized = JSON.stringify<Player>(player);
-const deserialized = JSON.parse<Player>(serialized);
-
-console.log("Serialized    " + serialized);
-console.log("Deserialized  " + JSON.stringify(deserialized));
+const good = `{"a":"a","b":"b","e":true,"c":"c","d":"d"}`;
+const good2 = `{"a":"a","b":"b","c":"c","d":"d","e":false}`;
+const bad = `{"a":"a","b":"b","e":false,"c":"c","d":"d"}`;
+const parsedGood = JSON.parse<Example>(good);
+console.log("a: " + JSON.stringify(parsedGood));
+const parsedGood2 = JSON.parse<Example>(good2);
+console.log("b: " + JSON.stringify(parsedGood2));
+const parsedBad = JSON.parse<Example>(bad);
+console.log("c: " + JSON.stringify(parsedBad));
+
+console.log(load<u64>(changetype<usize>("alse")).toString());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.1.21",
+  "version": "1.1.22",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "assemblyscript": "^0.28.4",
     "assemblyscript-prettier": "^3.0.1",
     "prettier": "^3.6.2",
-    "tinybench": "^4.1.0",
+    "tinybench": "^5.0.1",
     "typescript": "^5.9.2"
   },
   "bugs": {
@@ -57,7 +57,8 @@
     "test": "bash ./run-tests.sh",
     "bench:as": "bash ./run-bench.as.sh",
     "bench:js": "bash ./run-bench.js.sh",
-    "build:test": "rm -rf ./build/ && JSON_DEBUG=1 JSON_WRITE=assembly/test.ts asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --enable simd --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
+    "build:test": "rm -rf ./build/ && JSON_DEBUG=2 JSON_WRITE=assembly/test.ts asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --enable simd --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
+    "build:tmp:test": "rm -rf ./build/ && JSON_DEBUG=1 asc assembly/test.tmp.ts -o ./build/test.wasm --textFile ./build/test.wat --enable simd --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
     "build:test:wine": "JSON_DEBUG=1 JSON_WRITE=assembly/test.ts NODE_SKIP_PLATFORM_CHECK=1 wine ~/.win-bin/node/node.exe ./node_modules/assemblyscript/bin/asc.js assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:wasmer": "wasmer ./build/test.wasm",