json-as 0.5.35 → 0.5.37

package/README.md

@@ -8,15 +8,6 @@ JSON for AssemblyScript focused on performance, low-overhead, and ease-of-use.
 ```bash
 npm install json-as
 ```
-```bash
-npm install visitor-as --save-dev
-```
-
-For arbitrary-length numbers, use
-
-```bash
-npm install as-bignum
-```
 
 Add the transform to your `asc` command (e.g. in package.json)
 
@@ -75,26 +66,29 @@ const stringified = JSON.stringify<Player>(player);
 const parsed = JSON.parse<Player>(stringified);
 ```
 
-## Planned Features
-
-- [x] Serialize
-  - [x] Objects
-  - [x] Other Types
-  - [ ] Dynamic Types
-- [x] Deserialize
-  - [x] Objects
-  - [x] Other Types
-  - [ ] Dynamic Types
-- [ ] Streaming API
-- [ ] Whitespace support
-- [ ] Integrate features from SIMDJson
-- [x] Optimize
-  - [x] Strings
-  - [x] Int/Float
-  - [x] Bool
-  - [x] Object Serialization
-  - [ ] Object Parsing
-  - [ ] Arrays
+## Deviations from the spec
+
+This implementation does not hold strongly to the JSON specification. Rather, design and behavior are inspired by the JSON implementation found in Google's v8 engine.
+
+- No support for dynamic types
+- Unsafe by design--parser assumes valid JSON
+- Partial whitespace support--parser prefers speed over handling whitespace effectively. Users may use the `removeWhitespace` function provided by `json-as/src/util.ts`
+- Is not based off of the official spec, but rather the behavior of the JSON C implementation found in google's v8 engine
+- Support for scientific notation on integers. Float support coming soon.
+
+## Implemented features
+
+Fully supports:
+
+- Strings
+- Integers
+- Floats (Scientific notation not implemented)
+- Booleans
+- Arrays
+- Objects
+- Date
+- Null
+
 ## Performance
 
 Number parsing speed has doubled over the last 5 versions due to the use of a `atoi_fast` function found in `assembly/util.ts`. This can be further optimized with SIMD.
@@ -107,7 +101,7 @@ Schema (object) parsing is being optimized on GitHub and should be at least doub
 
 **Serialize Object (Vec3):** 6.7m ops/5s
 
-**Deserialize Object (Vec3):** 3.8m ops/5s
+**Deserialize Object (Vec3):** 5.1m ops/5s
 
 **Serialize Array (int[]):** 6.6m ops/5s
 

package/assembly/__benches__/as-json.ts

@@ -1,6 +1,6 @@
 import { JSON } from "..";
 import { backSlashCode, quoteCode } from "../src/chars";
-import { atoi_fast, unsafeCharCodeAt } from "../src/util";
+import { atoi_fast, parseSciInteger, unsafeCharCodeAt } from "../src/util";
 import { HASH } from "util/hash";
 
 @json
@@ -24,11 +24,11 @@ class Vec3 {
       if (inStr === false && char === quoteCode) {
         if (key != null) {
           if (unsafeCharCodeAt(key, 0) == 120) {
-            to.x = atoi_fast<i32>(data.substring(last, pos - 1))
+            to.x = parseSciInteger<i32>(data.substring(last, pos - 1))
           } else if (unsafeCharCodeAt(key, 0) == 121) {
-            to.y = atoi_fast<i32>(data.substring(last, pos - 1))
+            to.y = parseSciInteger<i32>(data.substring(last, pos - 1))
           } else if (unsafeCharCodeAt(key, 0) == 122) {
-            to.z = atoi_fast<i32>(data.substring(last, pos - 1))
+            to.z = parseSciInteger<i32>(data.substring(last, pos - 1))
           }
         }
         last = ++pos;
@@ -41,11 +41,11 @@ class Vec3 {
     }
     if (key != null) {
       if (unsafeCharCodeAt(key, 0) == 120) {
-        to.x = atoi_fast<i32>(data.substring(last, pos - 1))
+        to.x = parseSciInteger<i32>(data.substring(last, pos - 1))
       } else if (unsafeCharCodeAt(key, 0) == 121) {
-        to.y = atoi_fast<i32>(data.substring(last, pos - 1))
+        to.y = parseSciInteger<i32>(data.substring(last, pos - 1))
       } else if (unsafeCharCodeAt(key, 0) == 122) {
-        to.z = atoi_fast<i32>(data.substring(last, pos - 1))
+        to.z = parseSciInteger<i32>(data.substring(last, pos - 1))
       }
     }
     return to;
@@ -63,8 +63,8 @@ const vecOut = new Vec3();
 const i32Max = blackbox("429496729");
 /*
 bench("Stringify Object (Vec3)", () => {
-  blackbox<string>(vec.__JSON_Serialize(vec));
-});*/
+  blackbox<string>(vec.__JSON_Serialize());
+});
 
 bench("HASH String", () => {
   blackbox<number>(HASH("Hello"));
@@ -89,7 +89,7 @@ bench("Stringify Boolean Array", () => {
 bench("Stringify String Array", () => {
   blackbox(JSON.stringify<string[]>(["a", "b", "c"]));
 });
-
+*/
 bench("Stringify String", () => {
   blackbox(JSON.stringify(blackbox("Hello \"World!")));
 });
@@ -97,7 +97,7 @@ bench("Stringify String", () => {
 bench("Parse String", () => {
   blackbox(JSON.parse<string>(blackbox('"Hello \"World!"')));
 });
-
+/*
 bench("Stringify Boolean", () => {
   blackbox(JSON.stringify(blackbox(true)));
 });
@@ -120,4 +120,4 @@ bench("Stringify Float", () => {
 
 bench("Parse Float", () => {
   blackbox(JSON.parse<f32>(blackbox("3.14")));
-});
+});*/

package/assembly/src/json.ts

@@ -1,6 +1,4 @@
-import { u128, u128Safe, u256, u256Safe, i128, i128Safe } from "as-bignum/assembly";
 import { StringSink } from "as-string-sink/assembly";
-import { itoa32, itoa64, dtoa, dtoa_buffered } from "util/number";
 import { isSpace } from "util/string";
 import {
     backSlashCode,
@@ -23,7 +21,7 @@ import {
     uCode,
     emptyArrayWord
 } from "./chars";
-import { atoi_fast, escapeChar, isBigNum, unsafeCharCodeAt } from "./util";
+import { parseSciInteger, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -94,9 +92,6 @@ export namespace JSON {
                 result.write(rightBracketWord);
                 return result.toString();
             }
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return data.toString();
         } else {
             throw new Error(`Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
         }
@@ -133,9 +128,6 @@ export namespace JSON {
         } else if (idof<nonnull<T>>() == idof<Date>()) {
             // @ts-ignore
             return Date.fromString(data);
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return parseBigNum<T>(data);
         } else {
             // @ts-ignore
             throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
@@ -206,9 +198,6 @@ export namespace JSON {
         } else if (idof<nonnull<T>>() == idof<Date>()) {
             // @ts-ignore
             return Date.fromString(data);
-        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
-            // @ts-ignore
-            return parseBigNum<T>(data);
         } else {
             // @ts-ignore
             throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`)
@@ -221,8 +210,8 @@ export namespace JSON {
 @inline
 function serializeString(data: string): string {
     // @ts-ignore
-    if (data.length === 0) return "\"\"";
-    // Fast path for Vectors (3)
+    //if (data.length === 0) return "\"\"";
+   /*
     let char: i32 = 0;
     if (data.length === 1) {
         char = unsafeCharCodeAt(data, 0);
@@ -254,29 +243,26 @@ function serializeString(data: string): string {
         } 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);
+        const 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: {
+                /*case 0x5C: {
                     result += "\\\\";
                     break;
-                }
+                }*/
                 case 0x08: {
                     result += "\\b";
                     break;
@@ -300,40 +286,20 @@ function serializeString(data: string): string {
             }
         }
     }// 8 10 13 9 12
-    if (!found) return "\"" + data + "\"";
+    if (result.length === 1) return "\"" + data + "\"";
     else result += (<string>data).slice(last);
     return result + "\"";
 }
-// @ts-ignore
-@inline
-// @ts-ignore
-function parseBigNum<T>(data: string): T {
-    // @ts-ignore
-    if (idof<T>() == idof<u128>()) return u128.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u128Safe>()) return u128Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u256>()) return u128Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<u256Safe>()) return u256Safe.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<i128>()) return i128.fromString(data);
-    // @ts-ignore
-    if (idof<T>() == idof<i128Safe>()) return i128Safe.fromString(data);
-    // @ts-ignore
-    //if (idof<T>() == idof<i256Safe>()) return data.
-}
 
 // @ts-ignore
 @inline
 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);
+            const char = unsafeCharCodeAt(data, ++i);
             result += data.slice(last, i - 1)
             if (char === 34) {
                 result += "\"";
@@ -343,25 +309,40 @@ function parseString(data: string): string {
                 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;
+                switch (char) {
+                    case 92: {
+                        result += "\\";
+                        last = ++i;
+                        break;
+                    }
+                    case 98: {
+                        result += "\b";
+                        last = ++i;
+                        break;
+                    }
+                    case 102: {
+                        result += "\f";
+                        last = ++i;
+                        break;
+                    }
+                    case 114: {
+                        result += "\r";
+                        last = ++i;
+                        break;
+                    }
+                    case 116: {
+                        result += "\t";
+                        last = ++i;
+                        break;
+                    }
+                    default: {
+                        if (char === 117 && load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) === 27584753879220272) {
+                            result += "\u000b";
+                            i += 4;
+                            last = ++i;
+                        }
+                        break;
+                    }
                 }
             }
         }
@@ -384,7 +365,7 @@ function parseBoolean<T extends boolean>(data: string): T {
 export function parseNumber<T>(data: string): T {
     if (isInteger<T>()) {
         // @ts-ignore
-        return atoi_fast<T>(data);
+        return parseSciInteger<T>(data);
     }
     // @ts-ignore
     const type: T = 0;

package/assembly/src/util.ts

@@ -1,20 +1,6 @@
 import { StringSink } from "as-string-sink/assembly";
 import { CharCode, isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
-import { u128, u128Safe, u256, u256Safe, i128, i128Safe, i256Safe } from "as-bignum/assembly";
-
-// @ts-ignore
-@inline
-export function isBigNum<T>(): boolean {
-  if (idof<T>() == idof<u128>()) return true;
-  if (idof<T>() == idof<u128Safe>()) return true;
-  if (idof<T>() == idof<u256>()) return true;
-  if (idof<T>() == idof<u256Safe>()) return true;
-  if (idof<T>() == idof<i128>()) return true;
-  if (idof<T>() == idof<i128Safe>()) return true;
-  if (idof<T>() == idof<i256Safe>()) return true;
-  return false;
-}
 
 // @ts-ignore
 @inline
@@ -56,7 +42,7 @@ export function escapeChar(char: string): string {
     case 0x09: return "\\t";
     case 0x0C: return "\\f";
     case 0x0B: return "\\u000b";
-    default: return char; 
+    default: return char;
   }
 }
 
@@ -81,21 +67,67 @@ export function getArrayDepth<T>(depth: i32 = 1): i32 {
 
 /**
  * Implementation of ATOI. Can be much much faster with SIMD.
- * Its pretty fast. (173m ops (atoi_fast) vs 89 ops (parseInt))
+ * Benchmark: 40-46m ops/s
 */
 @unsafe
 @inline
-export function atoi_fast<T extends number>(str: string): T {
+export function atoi_fast<T extends number>(str: string, offset: i32 = 0): T {
   // @ts-ignore
   let val: T = 0;
-  for (let pos = 0; pos < (str.length << 1); pos += 2) {
+  for (; offset < (str.length << 1); offset += 2) {
     // @ts-ignore
-    val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>pos) - 48);
+    val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
     // We use load because in this case, there is no need to have bounds-checking
   }
   return val;
 }
 
 /**
- * 
- */
+ * Parses an integer using atoi_fast and applies the appended exponential number to it as scientific notation.
+ * Benchmark: Hovers around 30m ops/s
+ * Only safe if the string is valid.
+ * @param str integer to parse. example: 123e1, 123e-1, 123E100
+ * @returns 
+ */
+@inline
+export function parseSciInteger<T extends number>(str: string): T {
+  // @ts-ignore
+  let val: T = 0;
+  let offset = 0;
+  for (; offset < (str.length << 1); offset += 2) {
+    const char = load<u16>(changetype<usize>(str) + <usize>offset);
+    if (char === 101 || char === 69) {
+      const char = load<u16>(changetype<usize>(str) + <usize>(offset += 2));
+      if (char === 45) {
+        // @ts-ignore
+        val /= sciNote<T>(atoi_fast<T>(str, offset += 2));
+        // @ts-ignore
+        return val;
+      } else {
+        // @ts-ignore
+        val *= sciNote<T>(atoi_fast<T>(str, offset));
+        // @ts-ignore
+        return val;
+      }
+    }
+    // @ts-ignore
+    val = (val << 1) + (val << 3) + (char - 48);
+    // We use load because in this case, there is no need to have bounds-checking
+  }
+  return val;
+}
+
+function sciNote<T extends number>(num: T): T {
+  let res = 1;
+  if (num > 0) {
+    for (let i = 0; i < num; i++) {
+      res *= 10;
+    }
+  } else {
+    for (let i = 0; i < num; i++) {
+      res /= 10;
+    }
+  }
+  // @ts-ignore
+  return res;
+}

package/assembly/test.ts

@@ -1,6 +1,5 @@
-import { backSlashCode, quoteCode } from "./src/chars";
 import { JSON } from "./src/json";
-import { atoi_fast, unsafeCharCodeAt } from "./src/util";
+import { atoi_fast, parseSciInteger } from "./src/util";
 
 @json
 class Vec3 {
@@ -51,4 +50,12 @@ console.log(JSON.stringify(parsedVec3));
 
 console.log(`atoi_fast("429496729"): ${atoi_fast<i32>("429496729")}`);
 
-console.log(`strtol("429496729"): ${i32.parse("429496729")}`);
+console.log(`strtol("429496729"): ${i32.parse("429496729")}`);
+
+console.log(parseSciInteger<i32>("321").toString());
+console.log(parseSciInteger<i32>("321e1").toString());
+console.log(parseSciInteger<i32>("321e2").toString());
+console.log(parseSciInteger<i32>("321e3").toString());
+console.log(parseSciInteger<i32>("321e-1").toString());
+
+console.log(atoi_fast<i32>("321e1").toString());

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "json-as",
-  "version": "0.5.35",
+  "version": "0.5.37",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
   "contributors": [
     "DogWhich",
-    "Joshua Tenner",
-    "Rom"
+    "Romdotdog",
+    "Derek Barrera",
+    "Frankk Taylor",
+    "lekiano"
   ],
   "license": "MIT",
   "scripts": {
@@ -23,7 +25,6 @@
   "devDependencies": {
     "@as-pect/cli": "^8.0.1",
     "@as-tral/cli": "^2.0.0",
-    "@assemblyscript/loader": "^0.27.1",
     "@assemblyscript/wasi-shim": "^0.1.0",
     "assemblyscript": "^0.27.1",
     "assemblyscript-prettier": "^1.0.7",

package/transform/package.json

@@ -1,13 +1,15 @@
 {
     "name": "@json-as/transform",
-    "version": "0.5.35",
+    "version": "0.5.37",
     "description": "JSON encoder/decoder for AssemblyScript",
     "main": "./lib/index.js",
     "author": "Jairus Tanaka",
     "contributors": [
         "DogWhich",
-        "Joshua Tenner",
-        "Rom"
+        "Romdotdog",
+        "Derek Barrera",
+        "Frankk Taylor",
+        "lekiano"
     ],
     "license": "MIT",
     "devDependencies": {
@@ -31,4 +33,4 @@
     "homepage": "https://github.com/JairusSW/as-json#readme",
     "type": "module",
     "exports": "./lib/index.js"
-}
+}

package/transform/src/index.ts

@@ -61,7 +61,7 @@ class AsJSONTransform extends BaseVisitor {
     }
 
     const parentSchema = this.schemasList.find((v) => v.name == this.currentClass.parent);
-    const members = [...node.members, ...(parentSchema ? parentSchema.node.members : [])]
+    const members = [...node.members, ...(parentSchema ? parentSchema.node.members : [])];
 
     for (const mem of members) {
       if (mem.type && mem.type.name && mem.type.name.identifier.text) {
@@ -129,7 +129,7 @@ class AsJSONTransform extends BaseVisitor {
       this.currentClass.setDataStmts.join("")
       }
       }
-    `
+    `;
 
     const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
     node.members.push(serializeMethod);
@@ -164,7 +164,7 @@ export default class Transformer extends Transform {
       } else {
         return 0;
       }
-    })
+    });
 
     // Loop over every source
     for (const source of sources) {

package/build/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore