json-as 1.1.10 → 1.1.12

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Change Log
 
-## 2025-05-27 - 1.1.10
+## 2025-05-29 - 1.1.2
+
+- fix: add helpful warning on unknown or unaccessible types in fields
+- feat: support deserialization of class generics
+- fix: add support for numerical generics
+- tests: add proper testing for generics
+- feat: support type aliases with a custom type resolver/linker
+- chore: add other linkers to tsconfig and clean up
+- feat: add type alias resolving
+
+## 2025-05-28 - 1.1.11
+
+- fix: class resolving should only search top level statements for class declarations
+- fix: add helpful error if class is missing an @json decorator
+- fix: properly calculate relative path when json-as is a library
+- fix: add proper null check when resolving imported classes
+
+## 2025-05-28 - 1.1.10
 
 - feat: add more debug levels (1 = print transform code, 2 = print keys/values at runtime)
 - feat: add write out feature (`JSON_WRITE=path-to-file.ts`) which writes out generated code

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.1.10
+    AssemblyScript - v1.1.12
   </pre>
 </h6>
 

package/assembly/__tests__/generics.spec.ts

@@ -0,0 +1,40 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+@json
+class GenericTest<T> {
+    public foo: T;
+
+    constructor(foo: T) {
+        this.foo = foo;
+    }
+}
+
+@json
+class Vec3 {
+    public x!: i32;
+    public y!: i32;
+    public z!: i32;
+}
+
+describe("Should serialize generics", () => {
+    expect(JSON.stringify(new GenericTest<string>("bar"))).toBe('{"foo":"bar"}');
+    expect(JSON.stringify(new GenericTest<i32>(42))).toBe('{"foo":42}');
+    expect(JSON.stringify(new GenericTest<boolean>(true))).toBe('{"foo":true}');
+    expect(JSON.stringify(new GenericTest<Vec3>({ x: 1, y: 2, z: 3 }))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
+    expect(JSON.stringify(new GenericTest<string[]>(["item1", "item2"]))).toBe('{"foo":["item1","item2"]}');
+    expect(JSON.stringify(new GenericTest<Vec3[]>([{ x: 1, y: 2, z: 3 }, { x: 4, y: 5, z: 6 }]))).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
+    expect(JSON.stringify(new GenericTest<i32[]>([1, 2, 3]))).toBe('{"foo":[1,2,3]}');
+    expect(JSON.stringify(new GenericTest<boolean[]>([true, false, true]))).toBe('{"foo":[true,false,true]}');
+});
+
+describe("Should deserialize generics", () => {
+    expect(JSON.parse<GenericTest<string>>('{"foo":"bar"}').foo).toBe("bar");
+    expect(JSON.parse<GenericTest<i32>>('{"foo":42}').foo.toString()).toBe("42");
+    expect(JSON.parse<GenericTest<boolean>>('{"foo":true}').foo).toBe(true);
+    expect(JSON.stringify(JSON.parse<GenericTest<Vec3>>('{"foo":{"x":1,"y":2,"z":3}}'))).toBe('{"foo":{"x":1,"y":2,"z":3}}');
+    expect(JSON.stringify(JSON.parse<GenericTest<string[]>>('{"foo":["item1","item2"]}'))).toBe('{"foo":["item1","item2"]}');
+    expect(JSON.stringify(JSON.parse<GenericTest<Vec3[]>>('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}'))).toBe('{"foo":[{"x":1,"y":2,"z":3},{"x":4,"y":5,"z":6}]}');
+    expect(JSON.stringify(JSON.parse<GenericTest<i32[]>>('{"foo":[1,2,3]}'))).toBe('{"foo":[1,2,3]}');
+    expect(JSON.stringify(JSON.parse<GenericTest<boolean[]>>('{"foo":[true,false,true]}'))).toBe('{"foo":[true,false,true]}');
+});

package/assembly/__tests__/types.spec.ts

@@ -0,0 +1,26 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+type StringAlias = string;
+type StringAlias1 = StringAlias;
+type StringAlias2 = StringAlias1;
+type StringAlias3 = StringAlias2;
+type StringAlias4 = StringAlias3;
+
+@json
+class Alias {
+  public foo: StringAlias4 = "";
+  constructor(foo: StringAlias2) {
+    this.foo = foo;
+  }
+}
+
+const alias = new Alias("bar");
+
+describe("Should serialize with type aliases", () => {
+    expect(JSON.stringify(alias)).toBe('{"foo":"bar"}');
+});
+
+describe("Should deserialize with type aliases", () => {
+    expect(JSON.stringify(JSON.parse<Alias>('{"foo":"bar"}'))).toBe('{"foo":"bar"}');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "author": "Jairus Tanaka",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
@@ -19,8 +19,7 @@
     "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 asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
-    "build:test:simd": "rm -rf ./build/ && JSON_DEBUG=true asc assembly/test.ts --transform ./transform -o ./build/test.wasm --textFile ./build/test.wat --optimizeLevel 3 --shrinkLevel 0 --enable simd --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
+    "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 --debug --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:wasmer": "wasmer ./build/test.wasm",
     "build:transform": "tsc -p ./transform",

package/transform/lib/index.js

@@ -4,9 +4,10 @@ import { Visitor } from "./visitor.js";
 import { isStdlib, removeExtension, SimpleParser, toString } from "./util.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { Property, PropertyFlags, Schema } from "./types.js";
-import { getClass, getImportedClass } from "./linker.js";
+import { Property, PropertyFlags, Schema, Src } from "./types.js";
+import { getClass, getImportedClass } from "./linkers/classes.js";
 import { existsSync, writeFileSync } from "fs";
+import { CustomTransform } from "./linkers/custom.js";
 let indent = "  ";
 let id = 0;
 const WRITE = process.env["JSON_WRITE"];
@@ -19,35 +20,6 @@ const DEBUG = rawValue === "true"
             ? 0
             : Number(rawValue);
 const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
-class CustomTransform extends Visitor {
-    static SN = new CustomTransform();
-    modify = false;
-    visitCallExpression(node) {
-        super.visit(node.args, node);
-        if (node.expression.kind != 21 || node.expression.property.text != "stringify")
-            return;
-        if (node.expression.expression.kind != 6 || node.expression.expression.text != "JSON")
-            return;
-        if (this.modify) {
-            node.expression.expression = Node.createPropertyAccessExpression(Node.createIdentifierExpression("JSON", node.expression.range), Node.createIdentifierExpression("internal", node.expression.range), node.expression.range);
-        }
-        this.modify = true;
-    }
-    static visit(node, ref = null) {
-        if (!node)
-            return;
-        CustomTransform.SN.modify = true;
-        CustomTransform.SN.visit(node, ref);
-        CustomTransform.SN.modify = false;
-    }
-    static hasCall(node) {
-        if (!node)
-            return;
-        CustomTransform.SN.modify = false;
-        CustomTransform.SN.visit(node);
-        return CustomTransform.SN.modify;
-    }
-}
 class JSONTransform extends Visitor {
     static SN = new JSONTransform();
     program;
@@ -55,11 +27,20 @@ class JSONTransform extends Visitor {
     parser;
     schemas = new Map();
     schema;
-    sources = new Set();
+    src;
+    sources = new Map();
     imports = [];
-    topStatements = [];
     simdStatements = [];
     visitedClasses = new Set();
+    visitClassDeclarationRef(node) {
+        if (!node.decorators?.length ||
+            !node.decorators.some((decorator) => {
+                const name = decorator.name.text;
+                return name === "json" || name === "serializable";
+            }))
+            throw new Error("Class " + node.name.text + " is missing an @json or @serializable decorator in " + node.range.source.internalPath);
+        this.visitClassDeclaration(node);
+    }
     visitClassDeclaration(node) {
         if (!node.decorators?.length)
             return;
@@ -68,10 +49,17 @@ class JSONTransform extends Visitor {
             return name === "json" || name === "serializable";
         }))
             return;
-        if (this.visitedClasses.has(node.range.source.internalPath + node.name.text))
+        const source = node.range.source;
+        if (!this.sources.has(source.internalPath)) {
+            this.src = new Src(source);
+            this.sources.set(source.internalPath, this.src);
+        }
+        else
+            this.src = this.sources.get(source.internalPath);
+        if (this.visitedClasses.has(source.internalPath + node.name.text))
             return;
-        if (!this.schemas.has(node.range.source.internalPath))
-            this.schemas.set(node.range.source.internalPath, []);
+        if (!this.schemas.has(source.internalPath))
+            this.schemas.set(source.internalPath, []);
         const members = [...node.members.filter((v) => v.kind === 54 && v.flags !== 32 && v.flags !== 512 && v.flags !== 1024 && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
         const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer"))];
         const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer"))];
@@ -84,31 +72,44 @@ class JSONTransform extends Visitor {
                 const depSearch = schema.deps.find((v) => v.name == extendsName);
                 if (depSearch) {
                     if (DEBUG > 0)
-                        console.log("Found " + extendsName + " in dependencies of " + node.range.source.internalPath);
-                    schema.deps.push(depSearch);
+                        console.log("Found " + extendsName + " in dependencies of " + source.internalPath);
+                    if (!schema.deps.some(v => v.name == depSearch.name))
+                        schema.deps.push(depSearch);
                     schema.parent = depSearch;
                 }
                 else {
-                    const internalSearch = getClass(extendsName, node.range.source);
+                    const internalSearch = getClass(extendsName, source);
                     if (internalSearch) {
                         if (DEBUG > 0)
-                            console.log("Found " + extendsName + " internally from " + node.range.source.internalPath);
-                        this.visitClassDeclaration(internalSearch);
-                        schema.deps.push(this.schema);
-                        this.schemas.get(node.range.source.internalPath).push(this.schema);
-                        schema.parent = this.schema;
-                        this.schema = schema;
+                            console.log("Found " + extendsName + " internally from " + source.internalPath);
+                        if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+                            this.visitClassDeclarationRef(internalSearch);
+                            this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
+                            this.visitClassDeclaration(node);
+                            return;
+                        }
+                        const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find(s => s.name == internalSearch.name.text);
+                        if (!schem)
+                            throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
+                        schema.deps.push(schem);
+                        schema.parent = schem;
                     }
                     else {
-                        const externalSearch = getImportedClass(extendsName, node.range.source, this.parser);
+                        const externalSearch = getImportedClass(extendsName, source, this.parser);
                         if (externalSearch) {
                             if (DEBUG > 0)
-                                console.log("Found " + externalSearch.name.text + " externally from " + node.range.source.internalPath);
-                            this.visitClassDeclaration(externalSearch);
-                            schema.deps.push(this.schema);
-                            this.schemas.get(node.range.source.internalPath).push(this.schema);
-                            schema.parent = this.schema;
-                            this.schema = schema;
+                                console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
+                            if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+                                this.visitClassDeclarationRef(externalSearch);
+                                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                                this.visitClassDeclaration(node);
+                                return;
+                            }
+                            const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find(s => s.name == externalSearch.name.text);
+                            if (!schem)
+                                throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+                            schema.deps.push(schem);
+                            schema.parent = schem;
                         }
                     }
                 }
@@ -124,6 +125,7 @@ class JSONTransform extends Visitor {
         }
         const getUnknownTypes = (type, types = []) => {
             type = stripNull(type);
+            type = this.src.aliases.find(v => stripNull(v.name) == type)?.getBaseType() || type;
             if (type.startsWith("Array<")) {
                 return getUnknownTypes(type.slice(6, -1));
             }
@@ -153,42 +155,56 @@ class JSONTransform extends Visitor {
                 const depSearch = schema.deps.find((v) => v.name == unknownType);
                 if (depSearch) {
                     if (DEBUG > 0)
-                        console.log("Found " + unknownType + " in dependencies of " + node.range.source.internalPath);
-                    schema.deps.push(depSearch);
-                    continue;
-                }
-                const internalSearch = getClass(unknownType, node.range.source);
-                if (internalSearch) {
-                    if (DEBUG > 0)
-                        console.log("Found " + unknownType + " internally from " + node.range.source.internalPath);
-                    this.visitClassDeclaration(internalSearch);
-                    this.schemas.get(node.range.source.internalPath).push(this.schema);
-                    schema.deps.push(this.schema);
-                    this.schema = schema;
+                        console.log("Found " + unknownType + " in dependencies of " + source.internalPath);
+                    if (!schema.deps.some(v => v.name == depSearch.name))
+                        schema.deps.push(depSearch);
                 }
                 else {
-                    const externalSearch = getImportedClass(unknownType, node.range.source, this.parser);
-                    if (externalSearch) {
+                    const internalSearch = getClass(unknownType, source);
+                    if (internalSearch) {
                         if (DEBUG > 0)
-                            console.log("Found " + externalSearch.name.text + " externally from " + node.range.source.internalPath);
-                        this.visitClassDeclaration(externalSearch);
-                        this.schemas.get(node.range.source.internalPath).push(this.schema);
-                        schema.deps.push(this.schema);
-                        this.schema = schema;
+                            console.log("Found " + unknownType + " internally from " + source.internalPath);
+                        if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+                            this.visitClassDeclarationRef(internalSearch);
+                            this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
+                            this.visitClassDeclaration(node);
+                            return;
+                        }
+                        const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find(s => s.name == internalSearch.name.text);
+                        if (!schem)
+                            throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
+                        schema.deps.push(schem);
+                    }
+                    else {
+                        const externalSearch = getImportedClass(unknownType, source, this.parser);
+                        if (externalSearch) {
+                            if (DEBUG > 0)
+                                console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
+                            if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+                                this.visitClassDeclarationRef(externalSearch);
+                                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                                this.visitClassDeclaration(node);
+                                return;
+                            }
+                            const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find(s => s.name == externalSearch.name.text);
+                            if (!schem)
+                                throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+                            schema.deps.push(schem);
+                        }
                     }
                 }
             }
         }
-        this.schemas.get(node.range.source.internalPath).push(schema);
+        this.schemas.get(source.internalPath).push(schema);
         this.schema = schema;
-        this.visitedClasses.add(node.range.source.internalPath + node.name.text);
+        this.visitedClasses.add(source.internalPath + node.name.text);
         let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
         let INITIALIZE = "@inline __INITIALIZE(): this {\n";
         let DESERIALIZE = "__DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
         let DESERIALIZE_CUSTOM = "";
         let SERIALIZE_CUSTOM = "";
         if (DEBUG > 0)
-            console.log("Created schema: " + this.schema.name + " in file " + node.range.source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n  " + this.schema.deps.map((v) => v.name).join("\n  ") : ""));
+            console.log("Created schema: " + this.schema.name + " in file " + source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n  " + this.schema.deps.map((v) => v.name).join("\n  ") : ""));
         if (serializers.length > 1)
             throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
         if (deserializers.length > 1)
@@ -241,7 +257,8 @@ class JSONTransform extends Visitor {
         for (const member of members) {
             if (!member.type)
                 throwError("Fields must be strongly typed", node.range);
-            const type = toString(member.type);
+            let type = toString(member.type);
+            type = this.src.aliases.find(v => stripNull(v.name) == stripNull(type))?.getBaseType() || type;
             const name = member.name;
             const value = member.initializer ? toString(member.initializer) : null;
             if (type.startsWith("(") && type.includes("=>"))
@@ -396,21 +413,34 @@ class JSONTransform extends Visitor {
             object: [],
         };
         for (const member of this.schema.members) {
-            if (member.type.endsWith(" | null"))
-                sortedMembers.null.push(member);
-            if (isString(member.type) || member.type == "JSON.Raw")
+            const type = stripNull(member.type);
+            if (node.isGeneric && node.typeParameters.some((p) => stripNull(p.name.text) == type)) {
+                member.generic = true;
                 sortedMembers.string.push(member);
-            else if (isBoolean(member.type) || member.type.startsWith("JSON.Box<bool"))
-                sortedMembers.boolean.push(member);
-            else if (isPrimitive(member.type) || member.type.startsWith("JSON.Box<"))
                 sortedMembers.number.push(member);
-            else if (isArray(member.type))
-                sortedMembers.array.push(member);
-            else
                 sortedMembers.object.push(member);
+                sortedMembers.array.push(member);
+                sortedMembers.boolean.push(member);
+                sortedMembers.null.push(member);
+            }
+            else {
+                if (member.node.type.isNullable)
+                    sortedMembers.null.push(member);
+                if (isString(type) || type == "JSON.Raw")
+                    sortedMembers.string.push(member);
+                else if (isBoolean(type) || type.startsWith("JSON.Box<bool"))
+                    sortedMembers.boolean.push(member);
+                else if (isPrimitive(type) || type.startsWith("JSON.Box<"))
+                    sortedMembers.number.push(member);
+                else if (isArray(type))
+                    sortedMembers.array.push(member);
+                else if (isStruct(type, source))
+                    sortedMembers.object.push(member);
+                else
+                    throw new Error("Could not determine type " + type + " for member " + member.name + " in class " + this.schema.name);
+            }
         }
         indent = "";
-        let shouldGroup = false;
         DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
         DESERIALIZE += indent + "  let keyEnd: usize = 0;\n";
         DESERIALIZE += indent + "  let isKey = false;\n";
@@ -539,7 +569,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            if (" + (first.generic ? "isString<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "              srcStart += 4;\n";
                 DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -548,7 +578,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isString<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "              srcStart += 4;\n";
                     DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -587,7 +617,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            if (" + (first.generic ? "(isInteger<" + first.type + ">() || isFloat<" + first.type + ">()) && " : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "              srcStart += 2;\n";
                 DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -596,7 +626,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "(isInteger<" + mem.type + ">() || isFloat<" + mem.type + ">()) && " : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "              srcStart += 2;\n";
                     DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -642,7 +672,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            if (" + (first.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "              keyStart = 0;\n";
                 DESERIALIZE += indent + "              break;\n";
@@ -650,7 +680,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "              keyStart = 0;\n";
                     DESERIALIZE += indent + "              break;\n";
@@ -696,7 +726,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            if (" + (first.generic ? "isArray<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "              keyStart = 0;\n";
                 DESERIALIZE += indent + "              break;\n";
@@ -704,7 +734,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isArray" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "              keyStart = 0;\n";
                     DESERIALIZE += indent + "              break;\n";
@@ -740,7 +770,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "            srcStart += 2;\n";
                 DESERIALIZE += indent + "            keyStart = 0;\n";
@@ -749,7 +779,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "            srcStart += 2;\n";
                     DESERIALIZE += indent + "            keyStart = 0;\n";
@@ -784,7 +814,7 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "            srcStart += 2;\n";
                 DESERIALIZE += indent + "            keyStart = 0;\n";
@@ -793,7 +823,7 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "            srcStart += 2;\n";
                     DESERIALIZE += indent + "            keyStart = 0;\n";
@@ -830,8 +860,8 @@ class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
-                DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+                DESERIALIZE += indent + "          if (" + (first.generic ? "isNullable<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            store<usize>(changetype<usize>(out), 0, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "            srcStart += 2;\n";
                 DESERIALIZE += indent + "            keyStart = 0;\n";
                 DESERIALIZE += indent + "            break;\n";
@@ -839,8 +869,8 @@ class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
-                    DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
+                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isNullable<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + "            store<usize>(changetype<usize>(out), 0, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "            srcStart += 2;\n";
                     DESERIALIZE += indent + "            keyStart = 0;\n";
                     DESERIALIZE += indent + "            break;\n";
@@ -936,7 +966,7 @@ class JSONTransform extends Visitor {
             ? existsSync(path.join(pkgPath, fromPath.slice(5, fromPath.indexOf("/", 5))))
                 ? path.join(pkgPath, fromPath.slice(5))
                 : fromPath
-            : path.join(baseDir, fromPath);
+            : path.join(this.baseCWD, fromPath);
         const bsImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "bs" || d.name.text == "bs"));
         const jsonImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "JSON" || d.name.text == "JSON"));
         let bsRel = removeExtension(path.posix.join(...path
@@ -1063,10 +1093,6 @@ export default class Transformer extends Transform {
             transformer.imports = [];
             transformer.currentSource = source;
             transformer.visit(source);
-            if (transformer.topStatements.length) {
-                source.statements.unshift(...transformer.topStatements);
-                transformer.topStatements = [];
-            }
             if (transformer.simdStatements.length) {
                 for (const simd of transformer.simdStatements)
                     source.statements.unshift(SimpleParser.parseTopLevelStatement(simd));