json-as 0.9.20 → 0.9.22

package/transform/lib/index.js

@@ -1,76 +1,76 @@
-import { FieldDeclaration, IdentifierExpression, StringLiteralExpression, IntegerLiteralExpression, FloatLiteralExpression, NullExpression, TrueExpression, FalseExpression, } from "assemblyscript/dist/assemblyscript.js";
+import { FieldDeclaration, IdentifierExpression, StringLiteralExpression, IntegerLiteralExpression, FloatLiteralExpression, NullExpression, TrueExpression, FalseExpression, NamedTypeNode } from "assemblyscript/dist/assemblyscript.js";
 import { toString, isStdlib } from "visitor-as/dist/utils.js";
 import { BaseVisitor, SimpleParser } from "visitor-as/dist/index.js";
 import { Transform } from "assemblyscript/dist/transform.js";
+import chalk from "chalk";
+const json_types = ["Array", "string", "String", "u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "f32", "f64", "bool", "boolean", "Map", "Date"];
 class JSONTransform extends BaseVisitor {
-    constructor() {
-        super(...arguments);
-        this.schemasList = [];
-        this.sources = new Set();
+    types = json_types;
+    schemasList = [];
+    currentClass;
+    sources = new Set();
+    appendParentFields(node, schema, members) {
+        if (node.extendsType) {
+            if (schema.parent?.members) {
+                for (let i = schema.parent.members.length - 1; i >= 0; i--) {
+                    const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
+                    if (!replace) {
+                        members.unshift(schema.parent?.members[i].node);
+                    }
+                }
+                this.appendParentFields(schema.parent.node, schema, members);
+            }
+        }
+    }
+    handleEmptyClass(node, schema, members) {
+        let SERIALIZE_RAW_EMPTY = '__SERIALIZE(): string {\n  return "{}";\n}';
+        let SERIALIZE_PRETTY_EMPTY = '__SERIALIZE_PRETTY(): string {\n  return "{}";\n}';
+        let INITIALIZE_EMPTY = "__INITIALIZE(): this {\n  return this;\n}";
+        let DESERIALIZE_EMPTY = "__DESERIALIZE(data: string, key_start: i32, key_end: i32, value_start: i32, value_end: i32): boolean {\n  return false;\n}";
+        if (process.env["JSON_DEBUG"]) {
+            console.log(SERIALIZE_RAW_EMPTY);
+            console.log(SERIALIZE_PRETTY_EMPTY);
+            console.log(INITIALIZE_EMPTY);
+            console.log(DESERIALIZE_EMPTY);
+        }
+        const SERIALIZE_RAW_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_RAW_EMPTY, node);
+        const SERIALIZE_PRETTY_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_PRETTY_EMPTY, node);
+        const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
+        const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
+        if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
+            node.members.push(SERIALIZE_RAW_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__SERIALIZE_PRETTY"))
+            node.members.push(SERIALIZE_PRETTY_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
+            node.members.push(INITIALIZE_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
+            node.members.push(DESERIALIZE_METHOD_EMPTY);
+    }
+    filterMembers(members) {
+        return members.filter((v) => v instanceof FieldDeclaration && !v.decorators?.find((v) => v.name.text == "omit"));
     }
-    visitMethodDeclaration() { }
     visitClassDeclaration(node) {
         if (!node.decorators?.length)
             return;
-        let found = false;
-        for (const decorator of node.decorators) {
-            const name = decorator.name.text;
-            if (name === "json" || name === "serializable") {
-                found = true;
-                break;
-            }
-        }
-        if (!found)
+        if (!node.decorators.find((v) => v.name.text == "json" || v.name.text == "serializable"))
             return;
+        this.types = json_types;
         const schema = new SchemaData();
         schema.node = node;
         schema.name = node.name.text;
-        const members = [
-            ...node.members.filter((v) => v.kind === 54 /* NodeKind.FieldDeclaration */),
-        ];
         if (node.extendsType) {
             schema.parent = this.schemasList.find((v) => v.name == node.extendsType?.name.identifier.text);
-            if (schema.parent?.members) {
-                for (let i = schema.parent.members.length - 1; i >= 0; i--) {
-                    const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
-                    if (!replace) {
-                        members.unshift(schema.parent?.members[i].node);
-                    }
-                }
-            }
         }
+        const _members = [...node.members];
+        this.appendParentFields(node, schema, _members);
+        const members = this.filterMembers(_members);
         if (!members.length) {
-            let SERIALIZE_RAW_EMPTY = '__SERIALIZE(): string {\n  return "{}";\n}';
-            //let SERIALIZE_PRETTY_EMPTY = "__SERIALIZE_PRETTY(): string {\n  return \"{}\";\n}";
-            let INITIALIZE_EMPTY = "__INITIALIZE(): this {\n  return this;\n}";
-            let DESERIALIZE_EMPTY = "__DESERIALIZE(data: string, key_start: i32, key_end: i32, value_start: i32, value_end: i32): boolean {\n  return false;\n}";
-            if (process.env["JSON_DEBUG"]) {
-                console.log(SERIALIZE_RAW_EMPTY);
-                //console.log(SERIALIZE_PRETTY_EMPTY);
-                console.log(INITIALIZE_EMPTY);
-                console.log(DESERIALIZE_EMPTY);
-            }
-            const SERIALIZE_RAW_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_RAW_EMPTY, node);
-            //const SERIALIZE_PRETTY_METHOD = SimpleParser.parseClassMember(SERIALIZE_PRETTY, node);
-            const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
-            const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
-            if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
-                node.members.push(SERIALIZE_RAW_METHOD_EMPTY);
-            if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
-                node.members.push(INITIALIZE_METHOD_EMPTY);
-            if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
-                node.members.push(DESERIALIZE_METHOD_EMPTY);
-            this.schemasList.push(schema);
+            this.handleEmptyClass(node, schema, members);
         }
         for (const member of members) {
             const name = member.name;
-            if (!(member instanceof FieldDeclaration))
-                continue;
             if (!member.type) {
-                throw new Error("Fields must be strongly typed! Found " +
-                    toString(member) +
-                    " at " +
-                    node.range.source.normalizedPath);
+                throw new Error("Fields must be strongly typed! Found " + toString(member) + " at " + node.range.source.normalizedPath);
             }
             const type = toString(member.type);
             if (type.startsWith("(") && type.includes("=>"))
@@ -87,9 +87,12 @@ class JSONTransform extends BaseVisitor {
             mem.type = type;
             mem.value = value;
             mem.node = member;
-            if (type == "JSON.Raw") {
+            if (type.includes("JSON.Raw")) {
                 mem.flags.set(PropertyFlags.JSON_Raw, []);
             }
+            if (member.type.isNullable) {
+                mem.flags.set(PropertyFlags.Null, []);
+            }
             if (member.decorators) {
                 for (const decorator of member.decorators) {
                     const decoratorName = decorator.name.text;
@@ -97,8 +100,7 @@ class JSONTransform extends BaseVisitor {
                     switch (decoratorName) {
                         case "alias": {
                             if (!args.length)
-                                throw new Error("Expected 1 argument but got zero at @alias in " +
-                                    node.range.source.normalizedPath);
+                                throw new Error("Expected 1 argument but got zero at @alias in " + node.range.source.normalizedPath);
                             mem.alias = args[0];
                             mem.flags.set(PropertyFlags.Alias, args);
                             break;
@@ -109,8 +111,7 @@ class JSONTransform extends BaseVisitor {
                         }
                         case "omitif": {
                             if (!decorator.args?.length)
-                                throw new Error("Expected 1 argument but got zero at @omitif in " +
-                                    node.range.source.normalizedPath);
+                                throw new Error("Expected 1 argument but got zero at @omitif in " + node.range.source.normalizedPath);
                             mem.flags.set(PropertyFlags.OmitIf, args);
                             break;
                         }
@@ -121,22 +122,10 @@ class JSONTransform extends BaseVisitor {
                     }
                 }
             }
-            mem.generate();
+            if (!mem.flags.get(PropertyFlags.Omit))
+                mem.generate();
             if (this.schemasList.find((v) => v.name == type)) {
-                mem.initialize =
-                    "this." +
-                        name.text +
-                        " = changetype<nonnull<" +
-                        mem.type +
-                        ">>(__new(offsetof<nonnull<" +
-                        mem.type +
-                        ">>(), idof<nonnull<" +
-                        mem.type +
-                        ">>()));\n  changetype<nonnull<" +
-                        mem.type +
-                        ">>(this." +
-                        name.text +
-                        ").__INITIALIZE()";
+                mem.initialize = "this." + name.text + " = changetype<nonnull<" + mem.type + ">>(__new(offsetof<nonnull<" + mem.type + ">>(), idof<nonnull<" + mem.type + ">>()));\n  changetype<nonnull<" + mem.type + ">>(this." + name.text + ").__INITIALIZE()";
             }
             else if (mem.value) {
                 mem.initialize = "this." + name.text + " = " + mem.value;
@@ -148,8 +137,7 @@ class JSONTransform extends BaseVisitor {
                 mem.initialize = "this." + name.text + ' = ""';
             }
             else if (type === "Array") {
-                mem.initialize =
-                    "this." + name.text + " = instantiate<" + mem.type + ">()";
+                mem.initialize = "this." + name.text + " = instantiate<" + mem.type + ">()";
             }
             else if (type === "bool" || type === "boolean") {
                 mem.initialize = "this." + name.text + " = false";
@@ -157,14 +145,7 @@ class JSONTransform extends BaseVisitor {
             else if (type === "JSON.Raw") {
                 mem.initialize = "this." + name.text + ' = ""';
             }
-            else if (type === "u8" ||
-                type === "u16" ||
-                type === "u32" ||
-                type === "u64" ||
-                type === "i8" ||
-                type === "i16" ||
-                type === "i32" ||
-                type === "i64") {
+            else if (type === "u8" || type === "u16" || type === "u32" || type === "u64" || type === "i8" || type === "i16" || type === "i32" || type === "i64") {
                 mem.initialize = "this." + name.text + " = 0";
             }
             else if (type === "f32" || type === "f64") {
@@ -179,15 +160,14 @@ class JSONTransform extends BaseVisitor {
         let indent = "  ";
         if (!schema.members.length)
             return;
-        found = false;
-        if (schema.members[0]?.flags.has(PropertyFlags.OmitNull) ||
-            schema.members[0]?.flags.has(PropertyFlags.OmitIf)) {
+        let found = false;
+        if (schema.members[0]?.flags.has(PropertyFlags.OmitNull) || schema.members[0]?.flags.has(PropertyFlags.OmitIf)) {
             SERIALIZE_RAW += schema.members[0]?.serialize;
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize;
+            SERIALIZE_PRETTY += "\\n" + indent + schema.members[0]?.serialize_pretty;
         }
         else {
             SERIALIZE_RAW += schema.members[0]?.serialize + ",";
-            SERIALIZE_PRETTY += "\\n" + schema.members[0]?.serialize + ",\\n";
+            SERIALIZE_PRETTY += "\\n" + indent + schema.members[0]?.serialize_pretty + ",\\n";
             found = true;
         }
         if (schema.members[0]?.initialize)
@@ -196,89 +176,81 @@ class JSONTransform extends BaseVisitor {
             const member = schema.members[i];
             if (member.initialize)
                 INITIALIZE += "  " + member.initialize + ";\n";
-            if (member.flags.has(PropertyFlags.OmitNull) ||
-                member.flags.has(PropertyFlags.OmitIf)) {
+            if (member.flags.has(PropertyFlags.Omit))
+                continue;
+            if (member.flags.has(PropertyFlags.OmitNull) || member.flags.has(PropertyFlags.OmitIf)) {
                 SERIALIZE_RAW += member.serialize;
-                SERIALIZE_PRETTY += member.serialize;
+                SERIALIZE_PRETTY += member.serialize_pretty;
             }
             else {
                 SERIALIZE_RAW += member.serialize + ",";
-                SERIALIZE_PRETTY += indent + member.serialize + ",\\n";
+                SERIALIZE_PRETTY += indent + member.serialize_pretty + ",\\n";
                 found = true;
             }
         }
         if (found) {
-            SERIALIZE_RAW +=
-                "`;\n  store<u16>(changetype<usize>(out) + ((out.length - 1) << 1), 125);\n  return out;\n}";
-            SERIALIZE_PRETTY +=
-                "`;\n  store<u32>(changetype<usize>(out) + ((out.length - 2) << 1), 8192010);\n  return out;\n}";
+            SERIALIZE_RAW += "`;\n  store<u16>(changetype<usize>(out) + ((out.length - 1) << 1), 125);\n  return out;\n}";
+            SERIALIZE_PRETTY += "`;\n  store<u32>(changetype<usize>(out) + ((out.length - 2) << 1), 8192010);\n  return out;\n}";
         }
         else {
-            SERIALIZE_RAW += "`;\n};";
-            SERIALIZE_PRETTY += "`;\n};";
+            SERIALIZE_RAW += "}`;\n  return out;\n}";
+            SERIALIZE_PRETTY += "}`;\n  return out;\n}";
         }
         INITIALIZE += "  return this;\n}";
         const sortedMembers = [];
-        const _sorted = schema.members.sort((a, b) => a.name.length - b.name.length);
-        let len = 0;
-        let offset = 0;
-        sortedMembers.push([_sorted[0]]);
-        len = _sorted[0]?.name.length;
-        for (let i = 1; i < _sorted.length; i++) {
+        const _sorted = schema.members.sort((a, b) => (a.alias?.length || a.name.length) - (b.alias?.length || b.name.length));
+        let len = -1;
+        let offset = -1;
+        for (let i = 0; i < _sorted.length; i++) {
             const member = _sorted[i];
-            if (member.alias?.length || member.name.length > len) {
-                sortedMembers.push([member]);
-                len = member.alias?.length || member.name.length;
-                offset++;
+            const _name = member.alias || member.name;
+            if (_name.length === len) {
+                sortedMembers[offset]?.push(member);
             }
             else {
-                sortedMembers[offset].push(member);
+                sortedMembers.push([member]);
+                len = _name.length;
+                offset++;
             }
         }
         let first = true;
         for (const memberSet of sortedMembers) {
             const firstMember = memberSet[0];
-            const name = encodeKey(firstMember.alias || firstMember.name);
-            if (name.length === 1) {
+            const _name = encodeKey(firstMember.alias || firstMember.name);
+            if (_name.length === 1) {
                 if (first) {
-                    DESERIALIZE +=
-                        "  if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
+                    DESERIALIZE += "  if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
                     first = false;
                 }
                 else {
-                    DESERIALIZE +=
-                        "else if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
+                    DESERIALIZE += "else if (1 === len) {\n    switch (load<u16>(changetype<usize>(data) + (key_start << 1))) {\n";
                 }
             }
-            else if (name.length === 2) {
+            else if (_name.length === 2) {
                 if (first) {
-                    DESERIALIZE +=
-                        "  if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
+                    DESERIALIZE += "  if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
                     first = false;
                 }
                 else {
-                    DESERIALIZE +=
-                        "else if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
+                    DESERIALIZE += "else if (2 === len) {\n    switch (load<u32>(changetype<usize>(data) + (key_start << 1))) {\n";
                 }
             }
-            else if (name.length === 4) {
+            else if (_name.length === 4) {
                 if (first) {
-                    DESERIALIZE +=
-                        "  if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
+                    DESERIALIZE += "  if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
                     first = false;
                 }
                 else {
-                    DESERIALIZE +=
-                        "else if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
+                    DESERIALIZE += "else if (4 === len) {\n    const code = load<u64>(changetype<usize>(data) + (key_start << 1));\n";
                 }
             }
             else {
                 if (first) {
-                    DESERIALIZE += "  if (" + name.length + " === len) {\n";
+                    DESERIALIZE += "  if (" + _name.length + " === len) {\n";
                     first = false;
                 }
                 else {
-                    DESERIALIZE += "else if (" + name.length + " === len) {\n";
+                    DESERIALIZE += "else if (" + _name.length + " === len) {\n";
                 }
             }
             let f = true;
@@ -286,48 +258,40 @@ class JSONTransform extends BaseVisitor {
                 const member = memberSet[i];
                 if (!member.deserialize)
                     continue;
-                const name = encodeKey(member.alias || member.name);
-                if (name.length === 1) {
-                    DESERIALIZE += `      case ${name.charCodeAt(0)}: {\n        ${member.deserialize}\n        return true;\n      }\n`;
+                const _name = encodeKey(member.alias || member.name);
+                if (_name.length === 1) {
+                    DESERIALIZE += `      case ${_name.charCodeAt(0)}: { /* ${_name} */\n        ${member.deserialize}\n        return true;\n      }\n`;
                 }
-                else if (name.length === 2) {
-                    DESERIALIZE += `      case ${charCodeAt32(name, 0)}: {\n        ${member.deserialize}\n        return true;\n      }\n`;
+                else if (_name.length === 2) {
+                    DESERIALIZE += `      case ${charCodeAt32(_name, 0)}: { /* ${_name} */\n        ${member.deserialize}\n        return true;\n      }\n`;
                 }
-                else if (name.length === 4) {
+                else if (_name.length === 4) {
                     if (f) {
                         f = false;
-                        DESERIALIZE += `    if (${charCodeAt64(name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                        DESERIALIZE += `    if (${charCodeAt64(_name, 0)} === code) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
                     }
                     else {
-                        DESERIALIZE =
-                            DESERIALIZE.slice(0, DESERIALIZE.length - 1) +
-                                `else if (${charCodeAt64(name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + `else if (${charCodeAt64(_name, 0)} === code) {\n      ${member.deserialize}\n      return true;\n    }\n`;
                     }
                 }
                 else {
                     if (f) {
                         f = false;
-                        DESERIALIZE += `    if (0 == memory.compare(changetype<usize>("${escapeQuote(escapeSlash(name))}"), changetype<usize>(data) + (key_start << 1), ${name.length << 1})) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                        DESERIALIZE += `    if (0 === memory.compare(changetype<usize>("${escapeQuote(escapeSlash(_name))}"), changetype<usize>(data) + (key_start << 1), ${_name.length << 1})) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
                     }
                     else {
-                        DESERIALIZE =
-                            DESERIALIZE.slice(0, DESERIALIZE.length - 1) +
-                                ` else if (0 == memory.compare(changetype<usize>("${escapeQuote(escapeSlash(name))}"), changetype<usize>(data) + (key_start << 1), ${name.length << 1})) {\n      ${member.deserialize}\n      return true;\n    }\n`;
+                        DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else if (0 === memory.compare(changetype<usize>("${escapeQuote(escapeSlash(_name))}"), changetype<usize>(data) + (key_start << 1), ${_name.length << 1})) { /* ${_name} */\n      ${member.deserialize}\n      return true;\n    }\n`;
                     }
                 }
             }
-            if (name.length < 3) {
+            if (_name.length < 3) {
                 DESERIALIZE += `      default: {\n        return false;\n      }\n    }\n`;
             }
-            else if (name.length == 4) {
-                DESERIALIZE =
-                    DESERIALIZE.slice(0, DESERIALIZE.length - 1) +
-                        ` else {\n      return false;\n    }\n`;
+            else if (_name.length == 4) {
+                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
             }
             else {
-                DESERIALIZE =
-                    DESERIALIZE.slice(0, DESERIALIZE.length - 1) +
-                        ` else {\n      return false;\n    }\n`;
+                DESERIALIZE = DESERIALIZE.slice(0, DESERIALIZE.length - 1) + ` else {\n      return false;\n    }\n`;
             }
             DESERIALIZE += "  } ";
         }
@@ -335,16 +299,18 @@ class JSONTransform extends BaseVisitor {
         //console.log(sortedMembers);
         if (process.env["JSON_DEBUG"]) {
             console.log(SERIALIZE_RAW);
-            //console.log(SERIALIZE_PRETTY);
+            console.log(SERIALIZE_PRETTY);
             console.log(INITIALIZE);
             console.log(DESERIALIZE);
         }
         const SERIALIZE_RAW_METHOD = SimpleParser.parseClassMember(SERIALIZE_RAW, node);
-        //const SERIALIZE_PRETTY_METHOD = SimpleParser.parseClassMember(SERIALIZE_PRETTY, node);
+        const SERIALIZE_PRETTY_METHOD = SimpleParser.parseClassMember(SERIALIZE_PRETTY, node);
         const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
         const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_RAW_METHOD);
+        if (!node.members.find((v) => v.name.text == "__SERIALIZE_PRETTY"))
+            node.members.push(SERIALIZE_PRETTY_METHOD);
         if (!node.members.find((v) => v.name.text == "__INITIALIZE"))
             node.members.push(INITIALIZE_METHOD);
         if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
@@ -370,15 +336,13 @@ export default class Transformer extends Transform {
             .sort((_a, _b) => {
             const a = _a.internalPath;
             const b = _b.internalPath;
-            if (a[0] === "~" && b[0] !== "~") {
-                return -1;
-            }
-            else if (a[0] !== "~" && b[0] === "~") {
+            if (a[0] !== "~" && b[0] === "~") {
                 return 1;
             }
-            else {
-                return 0;
+            if (a[0] === "~" && b[0] !== "~") {
+                return -1;
             }
+            return 0;
         });
         // Loop over every source
         for (const source of sources) {
@@ -390,35 +354,92 @@ export default class Transformer extends Transform {
         // Check that every parent and child class is hooked up correctly
         const schemas = transformer.schemasList;
         for (const schema of schemas) {
-            if (schema.parent) {
-                const parent = schemas.find((v) => v.name === schema.parent?.name);
-                if (!parent)
-                    throw new Error(`Class ${schema.name} extends its parent class ${schema.parent}, but ${schema.parent} does not include a @json or @serializable decorator! Add the decorator and rebuild.`);
+            checkInheritance(schema, schemas);
+            const invalidType = checkTypeCorrectness(schema, schemas);
+            if (invalidType) {
+                logError(`Type ${invalidType.type} implemented in property ${invalidType.path} is not a JSON-compatible type!\nEither decorate it with @omit or fix it!`);
             }
         }
     }
 }
+function checkInheritance(schema, schemas) {
+    if (!schema.parent && schema.node.extendsType) {
+        if (schemas.find(v => v.node.name.text === schema.node.extendsType?.name.identifier.text))
+            return;
+        const extending = toString(schema.node.extendsType);
+        logError(`Schema ${schema.name} extends ${extending}, but ${extending} does not include the @json decorator!`);
+    }
+}
+function checkTypeCorrectness(schema, schemas) {
+    const parent = schemas.find((v) => v.name === schema.parent?.name);
+    const generic_types = [...(schema?.node.typeParameters?.map((v) => v.name.text) || []), ...(parent?.node.typeParameters?.map((v) => v.name.text) || [])];
+    const member_types = [...(schema.members.map((v) => v.node.type.name.identifier.text) || [])];
+    const scopeTypes = new Set([...json_types, ...generic_types, ...member_types]);
+    for (const typ of member_types) {
+        if (typ === "JSON")
+            continue; // JSON.Raw, JSON.Box, JSON.Any, ect...
+        if (json_types.includes(typ))
+            continue;
+        if (generic_types.includes(typ))
+            continue;
+        const check = schemas.find((v) => v.name == typ);
+        if (!check)
+            logError(`Type ${typ} is not a JSON compatible type or does not include the @json flag!`);
+    }
+    for (const member of schema.members) {
+        const invalidType = checkType(schema, schemas, member.node.type, member, scopeTypes, schema.name);
+        if (invalidType)
+            logError(`Type ${invalidType.type} in ${invalidType.path} does not implement a JSON compatible type!\n${chalk.dim(`  at ${member.node.range.source.normalizedPath.replace("~lib/", "./node_modules/")}`)}`);
+    }
+    return null;
+}
+function checkType(schema, schemas, typ, member, scopeTypes, path) {
+    path += "." + member.name;
+    if (schemas.find(v => v.node.name.text === typ.name.identifier.text))
+        scopeTypes.add(typ.name.identifier.text);
+    if (!scopeTypes.has(typ.name.identifier.text))
+        return { type: toString(typ), path };
+    if (typ.isNullable && isPrimitive(typ))
+        return { type: toString(typ), path };
+    if (typ.typeArguments?.length && typ.typeArguments?.length > 0) {
+        for (const ty of typ.typeArguments.filter((v) => v instanceof NamedTypeNode)) {
+            const check = checkType(schema, schemas, ty, member, scopeTypes, path);
+            if (check)
+                return { type: toString(typ), path };
+        }
+    }
+    else {
+        if (scopeTypes.has(typ.name.identifier.text))
+            return null;
+    }
+    return null;
+}
+function logError(message) {
+    console.log("\n" + chalk.bold.bgRed(" Error ") + chalk.dim(":") + " " + message + "\n");
+    process.exit(1);
+}
 var PropertyFlags;
 (function (PropertyFlags) {
-    PropertyFlags[PropertyFlags["Omit"] = 0] = "Omit";
-    PropertyFlags[PropertyFlags["OmitNull"] = 1] = "OmitNull";
-    PropertyFlags[PropertyFlags["OmitIf"] = 2] = "OmitIf";
-    PropertyFlags[PropertyFlags["Alias"] = 3] = "Alias";
-    PropertyFlags[PropertyFlags["JSON_Raw"] = 4] = "JSON_Raw";
+    PropertyFlags[PropertyFlags["Null"] = 0] = "Null";
+    PropertyFlags[PropertyFlags["Omit"] = 1] = "Omit";
+    PropertyFlags[PropertyFlags["OmitNull"] = 2] = "OmitNull";
+    PropertyFlags[PropertyFlags["OmitIf"] = 3] = "OmitIf";
+    PropertyFlags[PropertyFlags["Alias"] = 4] = "Alias";
+    PropertyFlags[PropertyFlags["JSON_Raw"] = 5] = "JSON_Raw";
 })(PropertyFlags || (PropertyFlags = {}));
 class Property {
-    constructor() {
-        this.name = "";
-        this.alias = null;
-        this.type = "";
-        this.value = null;
-        this.flags = new Map();
-        this.serialize = null;
-        this.deserialize = null;
-        this.initialize = null;
-        this.right_s = "";
-        this.right_d = "";
-    }
+    name = "";
+    alias = null;
+    type = "";
+    value = null;
+    flags = new Map();
+    serialize = null;
+    serialize_pretty = null;
+    deserialize = null;
+    initialize = null;
+    node;
+    right_s = "";
+    right_d = "";
     generate() {
         const name = this.name;
         const escapedName = escapeString(JSON.stringify(this.alias || this.name));
@@ -426,52 +447,44 @@ class Property {
         if (this.flags.has(PropertyFlags.Omit))
             return;
         if (this.flags.has(PropertyFlags.JSON_Raw)) {
-            this.right_s = "this." + name;
-            this.right_d = "data.substring(value_start, value_end);";
+            if (this.flags.has(PropertyFlags.Null)) {
+                this.right_s = "(this." + name + ' || "null")';
+                this.right_d = "value_start === value_end - 4 && 30399761348886638 === load<u64>(changetype<usize>(data) + (value_start << 1)) ? null : data.substring(value_start, value_end)";
+            }
+            else {
+                this.right_s = "this." + name;
+                this.right_d = "data.substring(value_start, value_end);";
+            }
         }
         else {
             this.right_s = "__SERIALIZE<" + type + ">(this." + name + ")";
-            this.right_d =
-                "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end))";
+            this.right_d = "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end))";
         }
         if (this.flags.has(PropertyFlags.OmitIf)) {
             const condition = this.flags.get(PropertyFlags.OmitIf)[0];
             if (!condition)
                 throw new Error("Could not find condition when using decorator @omitif! Provide at least one condition");
-            this.serialize =
-                "${" +
-                    condition +
-                    ' ? "" : \'' +
-                    escapedName +
-                    ":' + " +
-                    this.right_s +
-                    ' + ","}';
+            this.serialize = "${" + condition + ' ? "" : \'' + escapedName + ":' + " + this.right_s + ' + ","}';
+            this.serialize_pretty = "${" + condition + ' ? "" : \'' + escapedName + ": ' + " + this.right_s + ' + ","}';
             this.deserialize = "this." + name + " = " + this.right_d + ";";
         }
         else if (this.flags.has(PropertyFlags.OmitNull)) {
-            this.serialize =
-                "${changetype<usize>(this." +
-                    name +
-                    ") == <usize>0" +
-                    ' ? "" : \'' +
-                    escapedName +
-                    ":' + " +
-                    this.right_s +
-                    ' + ","}';
+            this.serialize = "${changetype<usize>(this." + name + ") == <usize>0" + ' ? "" : \'' + escapedName + ":' + " + this.right_s + ' + ","}';
+            this.serialize_pretty = "${changetype<usize>(this." + name + ") == <usize>0" + ' ? "" : \'' + escapedName + ": ' + " + this.right_s + ' + ","}';
             this.deserialize = "this." + name + " = " + this.right_d + ";";
         }
         else {
             this.serialize = escapedName + ":${" + this.right_s + "}";
+            this.serialize_pretty = escapedName + ": ${" + this.right_s + "}";
             this.deserialize = "this." + name + " = " + this.right_d + ";";
         }
     }
 }
 class SchemaData {
-    constructor() {
-        this.name = "";
-        this.members = [];
-        this.parent = null;
-    }
+    name = "";
+    members = [];
+    parent = null;
+    node;
 }
 function charCodeAt32(data, offset) {
     return (data.charCodeAt(offset + 1) << 16) | data.charCodeAt(offset);
@@ -484,10 +497,7 @@ function charCodeAt64(data, offset) {
     const secondCharCode = BigInt(data.charCodeAt(offset + 1));
     const thirdCharCode = BigInt(data.charCodeAt(offset + 2));
     const fourthCharCode = BigInt(data.charCodeAt(offset + 3));
-    const u64Value = (fourthCharCode << 48n) |
-        (thirdCharCode << 32n) |
-        (secondCharCode << 16n) |
-        firstCharCode;
+    const u64Value = (fourthCharCode << 48n) | (thirdCharCode << 32n) | (secondCharCode << 16n) | firstCharCode;
     return u64Value;
 }
 function encodeKey(key) {
@@ -532,3 +542,7 @@ function getArgs(args) {
     }
     return out;
 }
+function isPrimitive(type) {
+    const primitives = new Set(["u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "f32", "f64", "bool", "boolean"]);
+    return primitives.has(type.name.identifier.text);
+}