json-as 0.5.27 → 0.5.29

package/README.md

@@ -1,6 +1,8 @@
 # AS-JSON
 ![AssemblyScript](https://img.shields.io/badge/AssemblyScript-blue)
 ![WebAssembly](https://img.shields.io/badge/WebAssemby-purple)
+
+Probably the fastest JSON parser for AssemblyScript with many more optimizations coming down the pipeline.
 ## Installation
 
 ```bash
@@ -75,21 +77,21 @@ const parsed = JSON.parse<Player>(stringified);
 
 # Notes
 
-Performance is nearly equal to the JavaScript JSON implementation which is in C++.
+Performance exceeds JavaScript JSON implementation by an average of 230% but this decreases with larger data packets.
 
 ## Performance
 
-**Serialize Object (Vec2):** ~7.20m ops/s
+**Serialize Object (Vec3):** ~11.1m ops/s
 
-**Deserialize Object (Vec2):** ~2.2m ops/s
+**Deserialize Object (Vec3):** ~3.2m ops/s
 
-**Serialize Array (int[4]):** ~1.4m ops/s
+**Serialize Array (int[]):** ~1.4m ops/s
 
-**Deserialize Array (int[4]):** ~2.8m ops/s
+**Deserialize Array (int[]):** ~2.8m ops/s
 
-**Serialize String (5):** ~5.2m ops/sw
+**Serialize String (5):** ~4.2m ops/s
 
-**Deserialize String (5):** ~1.36m ops/s
+**Deserialize String (5):** ~12m ops/s
 
 ## Issues
 

package/assembly/__benches__/as-json.ts

@@ -2,29 +2,32 @@ import { JSON } from "..";
 
 @json
 class Vec3 {
-  x: f32;
-  y: f32;
-  z: f32;
+  x: i32;
+  y: i32;
+  z: i32;
 }
 
 const vec: Vec3 = blackbox<Vec3>({
-  x: 0.0,
-  y: 0.0,
-  z: 0.0
+  x: 0,
+  y: 0,
+  z: 0
 });
 
 bench("Stringify Object (Vec3)", () => {
   blackbox(JSON.stringify(vec));
-});/*
+});
 
 bench("Parse Object (Vec3)", () => {
-  blackbox(JSON.parse<Vec3>(blackbox('{"x":0.0,"y":0.0,"z":0.0}')));
-});
+  blackbox(JSON.parse<Vec3>(blackbox('{"x":0,"y":0,"z":0}')));
+});/*
 
 bench("Stringify Array", () => {
   blackbox(JSON.stringify(blackbox([1, 2, 3, 4, 5])));
 });
-
+bench("Stringify String Array", () => {
+  blackbox(JSON.stringify(blackbox(["a", "b", "c", "d", "e"])));
+});
+/*
 bench("Parse Array", () => {
   blackbox(JSON.parse<i32[]>(blackbox("[1,2,3,4]")));
 });
@@ -41,8 +44,8 @@ bench("Stringify Nested Array", () => {
 
 bench("Parse Nested Array", () => {
   blackbox(JSON.parse<string[][]>(blackbox('[["a","b","c"]]')));
-});*/
-
+});
+*/
 bench("Stringify String", () => {
   blackbox(JSON.stringify(blackbox("Hello \"World!")));
 });

package/assembly/src/json.ts

@@ -40,65 +40,7 @@ export namespace JSON {
     export function stringify<T>(data: T): string {
         // String
         if (isString<T>() && data != null) {
-            // @ts-ignore
-            if (data.length === 0) return "\"\"";
-
-            let result = "\"";
-
-            let char: i32 = 0;
-            let last: i32 = 0;
-            let found: boolean = false;
-            // @ts-ignore
-            for (let i = 0; i < data.length; i++) {
-                char = unsafeCharCodeAt(<string>data, i);
-                if (char === 34 || char === 92) {
-                    result += (<string>data).slice(last, i) + "\\";
-                    last = i;
-                    found = true;
-                    i++;
-                } else if (char <= 13 && char >= 8) {
-                    result += (<string>data).slice(last, i);
-                    last = ++i;
-                    found = true;
-                    switch (char) {
-                        case 0x22: {
-                            result += "\\\"";
-                            break;
-                        }
-                        case 0x5C: {
-                            result += "\\\\";
-                            break;
-                        }
-                        case 0x08: {
-                            result += "\\b";
-                            break;
-                        }
-                        case 0x0A: {
-                            result += "\\n";
-                            break;
-                        }
-                        case 0x0D: {
-                            result += "\\r";
-                            break;
-                        }
-                        case 0x09: {
-                            result += "\\t";
-                            break;
-                        }
-                        case 0x0C: {
-                            result += "\\f";
-                            break;
-                        }
-                        case 0x0B: {
-                            result += "\\u000b";
-                            break;
-                        }
-                    }
-                }
-            }// 8 10 13 9 12
-            if (!found) return "\"" + data + "\"";
-            else result += (<string>data).slice(last);
-            return result + "\"";
+            return serializeString(data);
         }
         // Boolean
         else if (isBoolean<T>()) {
@@ -124,19 +66,44 @@ export namespace JSON {
         }
         // ArrayLike
         else if (isArrayLike<T>()) {
-            let result = new StringSink(leftBracketWord);
-            // @ts-ignore
-            if (data.length == 0) return emptyArrayWord;
             // @ts-ignore
-            for (let i = 0; i < data.length - 1; i++) {
+            if (data.length == 0) {
+                return emptyArrayWord;
+            } else if (isString<valueof<T>>()) {
+                let result = "[";
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result += serializeString(unchecked(data[i]));
+                    result += commaWord;
+                }
+                result += serializeString(unchecked(data[data.length - 1]));
+                result += rightBracketWord;
+                return result;
+            } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+                let result = new StringSink(leftBracketWord);
+                // @ts-ignore
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result.write(JSON.stringify(unchecked(data[i])));
+                    result.write(commaWord);
+                }
+                // @ts-ignore
+                result.write(JSON.stringify(unchecked(data[data.length - 1])));
+                result.write(rightBracketWord);
+                return result.toString();
+            } else {
+                let result = new StringSink(leftBracketWord);
+                // @ts-ignore
+                for (let i = 0; i < data.length - 1; i++) {
+                    // @ts-ignore
+                    result.write(JSON.stringify(unchecked(data[i])));
+                    result.write(commaWord);
+                }
                 // @ts-ignore
-                result.write(JSON.stringify(unchecked(data[i])));
-                result.write(commaWord);
+                result.write(JSON.stringify(unchecked(data[data.length - 1])));
+                result.write(rightBracketWord);
+                return result.toString();
             }
-            // @ts-ignore
-            result.write(JSON.stringify(unchecked(data[data.length - 1])));
-            result.write(rightBracketWord);
-            return result.toString();
         } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
             // @ts-ignore
             return data.toString();
@@ -212,6 +179,94 @@ export namespace JSON {
     }
 }
 
+// @ts-ignore
+@inline
+// @ts-ignore
+function serializeString(data: string): string {
+    // @ts-ignore
+    if (data.length === 0) return "\"\"";
+    // Fast path for Vectors (3)
+    let char: i32 = 0;
+    if (data.length === 1) {
+        char === unsafeCharCodeAt(data, 0);
+        if (char === 34) {
+            return "\\\"";
+        } else if (char === 92) {
+            return "\\n";
+        } else if (char <= 13 && char >= 8) {
+            switch (char) {
+                case 0x5C: {
+                    return "\\\\";
+                }
+                case 0x08: {
+                    return "\\b";
+                }
+                case 0x0D: {
+                    return "\\r";
+                }
+                case 0x09: {
+                    return "\\t";
+                }
+                case 0x0C: {
+                    return "\\f";
+                }
+                case 0x0B: {
+                    return "\\u000b";
+                }
+            }
+        } else {
+            return data;
+        }
+    }
+
+    let result = "\"";
+
+    let last: i32 = 0;
+    let found: boolean = false;
+    // @ts-ignore
+    for (let i = 0; i < data.length; i++) {
+        char = unsafeCharCodeAt(<string>data, i);
+        if (char === 34 || char === 92) {
+            result += (<string>data).slice(last, i) + "\\";
+            last = i;
+            found = true;
+            i++;
+        } else if (char <= 13 && char >= 8) {
+            result += (<string>data).slice(last, i);
+            last = ++i;
+            found = true;
+            switch (char) {
+                case 0x5C: {
+                    result += "\\\\";
+                    break;
+                }
+                case 0x08: {
+                    result += "\\b";
+                    break;
+                }
+                case 0x0D: {
+                    result += "\\r";
+                    break;
+                }
+                case 0x09: {
+                    result += "\\t";
+                    break;
+                }
+                case 0x0C: {
+                    result += "\\f";
+                    break;
+                }
+                case 0x0B: {
+                    result += "\\u000b";
+                    break;
+                }
+            }
+        }
+    }// 8 10 13 9 12
+    if (!found) return "\"" + data + "\"";
+    else result += (<string>data).slice(last);
+    return result + "\"";
+}
 // @ts-ignore
 @inline
 // @ts-ignore
@@ -235,7 +290,47 @@ function parseBigNum<T>(data: string): T {
 // @ts-ignore
 @inline
 function parseString(data: string): string {
-    return data.slice(1, data.length - 1).replaceAll('\\"', '"');
+    let result = "";
+    let last = 1;
+    let char = 0;
+    for (let i = 1; i < data.length - 1; i++) {
+        // \\"
+        if (unsafeCharCodeAt(data, i) === backSlashCode) {
+            char = unsafeCharCodeAt(data, ++i);
+            result += data.slice(last, i - 1)
+            if (char === 34) {
+                result += "\"";
+                last = ++i;
+            } else if (char === 110) {
+                result += "\n";
+                last = ++i;
+                // 92 98 114 116 102 117
+            } else if (char >= 92 && char <= 117) {
+                if (char === 92) {
+                    result += "\\";
+                    last = ++i;
+                } else if (char === 98) {
+                    result += "\b";
+                    last = ++i;
+                } else if (char === 102) {
+                    result += "\f";
+                    last = ++i;
+                } else if (char === 114) {
+                    result += "\r";
+                    last = ++i;
+                } else if (char === 116) {
+                    result += "\t";
+                    last = ++i;
+                } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+                    result += "\u000b";
+                    i += 4;
+                    last = ++i;
+                }
+            }
+        }
+    }
+    result += data.slice(last, data.length - 1);
+    return result;
 }
 
 // @ts-ignore

package/assembly/test.ts

@@ -2,10 +2,11 @@ import { u128 } from "as-bignum/assembly";
 import {
   JSON
 } from ".";
+import { unsafeCharCodeAt } from "./src/util";
+import { backSlashCode, quoteCode } from "./src/chars";
 
 const exp = `["abcdefg","st\\"ring\\" w\\"\\"ith quotes\\"","string \\t\\r\\"with ran\\tdom spa\\nces and \\nnewlines\\n\\n\\n","string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\""]`;
 
-///console.log(exp);
 /*console.log(JSON.stringify([
   "abcdefg",
   'st"ring" w""ith quotes"',
@@ -13,6 +14,60 @@ const exp = `["abcdefg","st\\"ring\\" w\\"\\"ith quotes\\"","string \\t\\r\\"wit
   'string with colon : comma , brace [ ] bracket { } and quote " and other quote "',
 ]));*/
 
+const str = "\\\""
+
+function parseString(data: string): string {
+  let result = "";
+  let last = 1;
+  let char = 0;
+  for (let i = 1; i < data.length - 1; i++) {
+    // \\"
+    if (unsafeCharCodeAt(data, i) === backSlashCode) {
+      char = unsafeCharCodeAt(data, ++i);
+      result += data.slice(last, i - 1)
+      if (char === 34) {
+        result += "\"";
+        last = ++i;
+      } else if (char === 110) {
+        result += "\n";
+        last = ++i;
+        // 92 98 114 116 102 117
+      } else if (char >= 92 && char <= 117) {
+        if (char === 92) {
+          result += "\\";
+          last = ++i;
+        } else if (char === 98) {
+          result += "\b";
+          last = ++i;
+        } else if (char === 102) {
+          result += "\f";
+          last = ++i;
+        } else if (char === 114) {
+          result += "\r";
+          last = ++i;
+        } else if (char === 116) {
+          result += "\t";
+          last = ++i;
+        } else if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+          result += "\u000b";
+          i += 4;
+          last = ++i;
+        }
+      }
+    }
+  }
+  result += data.slice(last, data.length - 1);
+  return result;
+}
+
+console.log(parseString("\"Hello W\\\"orld!\""));
+console.log(parseString("\"Hello New \\nWorld!\""));
+console.log(parseString("\"\\t TAB Hello World!\""));
+console.log(JSON.stringify(parseString("\"U000B \\u000b Hello World!\"")));
+console.log(load<u32>(changetype<usize>(str)).toString());
+console.log(load<u8>(changetype<usize>(str)).toString());
+console.log(load<u8>(changetype<usize>(str) + <usize>2).toString());
+
 console.log("abcdefg");
 console.log('st"ring" w""ith quotes"');
 console.log('string \t\r"with ran\tdom spa\nces and \nnewlines\n\n\n');
@@ -24,6 +79,8 @@ console.log(JSON.stringify('string \t\r"with ran\tdom spa\nces and \nnewlines\n\
 console.log(JSON.stringify('string with colon : comma , brace [ ] bracket { } and quote " and other quote "'));
 
 console.log(JSON.stringify("Hello W\"orld!"));
+
+console.log("U000B: \u000b")
 // @ts-ignore
 @JSON
 class Vec3 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.27",
+  "version": "0.5.29",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",

package/transform/lib/index.js

@@ -31,13 +31,18 @@ class AsJSONTransform extends BaseVisitor {
         }
         let type = getName(node.type);
         // @ts-ignore
-        this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
+        if (["u8", "i8", "u16", "i16", "u32", "i32", "f32", "u64", "i64", "f64"].includes(type.toLowerCase())) {
+            this.currentClass.encodeStmts.push(`"${name}":\${this.${name}.toString()},`);
+        }
+        else {
+            this.currentClass.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
+        }
         // @ts-ignore
         //this.decodeStmts.push(
         //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
         //);
         // @ts-ignore
-        this.currentClass.setDataStmts.push(`if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.currentClass.setDataStmts.push(`if (key == "${name}") {
         this.${name} = JSON.parseObjectValue<${type}>(value);
         return;
       }
@@ -93,6 +98,7 @@ class AsJSONTransform extends BaseVisitor {
             const stmt = this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1];
             this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
@@ -100,12 +106,14 @@ class AsJSONTransform extends BaseVisitor {
         }
         else {
             serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
         const setKeyFunc = `
+      @inline
       __JSON_Set_Key(key: string, value: string): void {
         ${
         // @ts-ignore
@@ -117,6 +125,8 @@ class AsJSONTransform extends BaseVisitor {
         const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
         node.members.push(setDataMethod);
         this.schemasList.push(this.currentClass);
+        console.log(serializeFunc);
+        console.log(setKeyFunc);
     }
     visitSource(node) {
         super.visitSource(node);

package/transform/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@json-as/transform",
-    "version": "0.5.27",
+    "version": "0.5.29",
     "description": "JSON encoder/decoder for AssemblyScript",
     "main": "./lib/index.js",
     "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -35,9 +35,15 @@ class AsJSONTransform extends BaseVisitor {
 
     let type = getName(node.type);
     // @ts-ignore
-    this.currentClass.encodeStmts.push(
-      `"${name}":\${JSON.stringify<${type}>(this.${name})},`
-    );
+    if (["u8", "i8", "u16", "i16", "u32", "i32", "f32", "u64", "i64", "f64"].includes(type.toLowerCase())) {
+      this.currentClass.encodeStmts.push(
+        `"${name}":\${this.${name}.toString()},`
+      );
+    } else {
+      this.currentClass.encodeStmts.push(
+        `"${name}":\${JSON.stringify<${type}>(this.${name})},`
+      );
+    }
 
     // @ts-ignore
     //this.decodeStmts.push(
@@ -46,7 +52,7 @@ class AsJSONTransform extends BaseVisitor {
 
     // @ts-ignore
     this.currentClass.setDataStmts.push(
-      `if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+      `if (key == "${name}") {
         this.${name} = JSON.parseObjectValue<${type}>(value);
         return;
       }
@@ -107,12 +113,14 @@ class AsJSONTransform extends BaseVisitor {
         stmt.length - 1
       );
       serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }
       `;
     } else {
       serializeFunc = `
+      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
@@ -120,6 +128,7 @@ class AsJSONTransform extends BaseVisitor {
     }
 
     const setKeyFunc = `
+      @inline
       __JSON_Set_Key(key: string, value: string): void {
         ${
       // @ts-ignore
@@ -138,6 +147,9 @@ class AsJSONTransform extends BaseVisitor {
     node.members.push(setDataMethod);
 
     this.schemasList.push(this.currentClass);
+
+    console.log(serializeFunc);
+    console.log(setKeyFunc);
   }
   visitSource(node: Source): void {
     super.visitSource(node);