json-as 0.5.36 → 0.5.38

package/README.md

@@ -1,122 +1,118 @@
-# AS-JSON
-![AssemblyScript](https://img.shields.io/badge/AssemblyScript-blue)
-![WebAssembly](https://img.shields.io/badge/WebAssemby-purple)
-
-JSON for AssemblyScript focused on performance, low-overhead, and ease-of-use.
-## Installation
-
-```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)
-
-```bash
---transform json-as/transform
-```
-
-Alternatively, add it to your `asconfig.json`
-
-```
-{
-  "options": {
-    "transform": ["json-as/transform"]
-  }
-}
-```
-
-## Usage
-
-```js
-import { JSON } from "json-as/assembly";
-
-// @json or @serializable work here
-@json
-class Vec3 {
-  x!: f32;
-  y!: f32;
-  z!: f32;
-}
-
-@json
-class Player {
-  firstName!: string;
-  lastName!: string;
-  lastActive!: i32[];
-  age!: i32;
-  pos!: Vec3 | null;
-  isVerified!: boolean;
-}
-
-const player: Player = {
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: {
-    x: 3.4,
-    y: 1.2,
-    z: 8.3
-  },
-  isVerified: true
-};
-
-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
-## 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.
-
-String serialization has more than tripled in performance (+360%). The algorithm was rewritten for less if statements and more traps.
-
-String deserialization was quadrupled from 3.4m ops to 14.8 ops (435%). It went from using `.replaceAll` to a specialized algorithm.
-
-Schema (object) parsing is being optimized on GitHub and should be at least doubled if not tripled. (Current speed of barely-optimized version is 6.9m ops) This is due to taking advantage of the types with a type map and eliminating extra checking.
-
-**Serialize Object (Vec3):** 6.7m ops/5s
-
-**Deserialize Object (Vec3):** 3.8m ops/5s
-
-**Serialize Array (int[]):** 6.6m ops/5s
-
-**Deserialize Array (int[]):** 8.6m ops/5s
-
-**Serialize String (5):** 5.9m ops/5s
-
-**Deserialize String (5):** 16.3m ops/5s
-
-## Issues
-
-Please submit an issue to https://github.com/JairusSW/as-json/issues if you find anything wrong with this library
+# AS-JSON
+
+![AssemblyScript](https://img.shields.io/badge/AssemblyScript-blue)
+![WebAssembly](https://img.shields.io/badge/WebAssemby-purple)
+
+JSON for AssemblyScript focused on performance, low-overhead, and ease-of-use.
+
+## Installation
+
+```bash
+npm install json-as
+```
+
+Add the transform to your `asc` command (e.g. in package.json)
+
+```bash
+--transform json-as/transform
+```
+
+Alternatively, add it to your `asconfig.json`
+
+```
+{
+  "options": {
+    "transform": ["json-as/transform"]
+  }
+}
+```
+
+## Usage
+
+```js
+import { JSON } from "json-as/assembly";
+
+// @json or @serializable work here
+@json
+class Vec3 {
+  x!: f32;
+  y!: f32;
+  z!: f32;
+}
+
+@json
+class Player {
+  firstName!: string;
+  lastName!: string;
+  lastActive!: i32[];
+  age!: i32;
+  pos!: Vec3 | null;
+  isVerified!: boolean;
+}
+
+const player: Player = {
+  firstName: "Emmet",
+  lastName: "West",
+  lastActive: [8, 27, 2022],
+  age: 23,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3
+  },
+  isVerified: true
+};
+
+const stringified = JSON.stringify<Player>(player);
+
+const parsed = JSON.parse<Player>(stringified);
+```
+
+## 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.
+
+String serialization has more than tripled in performance (+360%). The algorithm was rewritten for less if statements and more traps.
+
+String deserialization was quadrupled from 3.4m ops to 14.8 ops (435%). It went from using `.replaceAll` to a specialized algorithm.
+
+Schema (object) parsing is being optimized on GitHub and should be at least doubled if not tripled. (Current speed of barely-optimized version is 6.9m ops) This is due to taking advantage of the types with a type map and eliminating extra checking.
+
+**Serialize Object (Vec3):** 6.7m ops/5s
+
+**Deserialize Object (Vec3):** 5.1m ops/5s
+
+**Serialize Array (int[]):** 6.6m ops/5s
+
+**Deserialize Array (int[]):** 8.6m ops/5s
+
+**Serialize String (5):** 5.9m ops/5s
+
+**Deserialize String (5):** 16.3m ops/5s
+
+## Issues
+
+Please submit an issue to https://github.com/JairusSW/as-json/issues if you find anything wrong with this library

package/as-pect.asconfig.json

@@ -1,24 +1,24 @@
-{
-  "targets": {
-    "coverage": {
-      "lib": ["@as-covers/assembly/index.ts"],
-      "transform": ["@as-covers/transform", "@as-pect/transform"]
-    },
-    "noCoverage": {
-      "transform": ["@as-pect/transform"]
-    }
-  },
-  "options": {
-    "exportMemory": true,
-    "outFile": "output.wasm",
-    "textFile": "output.wat",
-    "bindings": "raw",
-    "exportStart": "_start",
-    "exportRuntime": true,
-    "use": ["RTRACE=1"],
-    "debug": true,
-    "exportTable": true
-  },
-  "extends": "./asconfig.json",
-  "entries": ["./node_modules/@as-pect/assembly/assembly/index.ts"]
-}
+{
+  "targets": {
+    "coverage": {
+      "lib": ["@as-covers/assembly/index.ts"],
+      "transform": ["@as-covers/transform", "@as-pect/transform"]
+    },
+    "noCoverage": {
+      "transform": ["@as-pect/transform"]
+    }
+  },
+  "options": {
+    "exportMemory": true,
+    "outFile": "output.wasm",
+    "textFile": "output.wat",
+    "bindings": "raw",
+    "exportStart": "_start",
+    "exportRuntime": true,
+    "use": ["RTRACE=1"],
+    "debug": true,
+    "exportTable": true
+  },
+  "extends": "./asconfig.json",
+  "entries": ["./node_modules/@as-pect/assembly/assembly/index.ts"]
+}

package/asconfig.json

@@ -1,17 +1,18 @@
-{
-  "targets": {
-    "test": {
-      "outFile": "build/test.wasm",
-      "sourceMap": false,
-      "optimizeLevel": 0,
-      "shrinkLevel": 0,
-      "converge": false,
-      "noAssert": false
-    }
-  },
-  "options": {
-    "transform": [
-      "./transform"
-    ]
-  }
-}
+{
+  "targets": {
+    "test": {
+      "outFile": "build/test.wasm",
+      "sourceMap": false,
+      "optimizeLevel": 0,
+      "shrinkLevel": 0,
+      "converge": false,
+      "noAssert": false
+    }
+  },
+  "options": {
+    "transform": ["./transform"],
+    "bindings": "esm",
+    "exportStart": "_start"
+  },
+  "extends": "./node_modules/@assemblyscript/wasi-shim/asconfig.json"
+}

package/assembly/__benches__/as-json.ts

@@ -1,6 +1,6 @@
 import { JSON } from "..";
 import { backSlashCode, quoteCode } from "../src/chars";
-import { parseJSONInt, unsafeCharCodeAt } from "../src/util";
+import { atoi_fast, parseSciInteger, unsafeCharCodeAt } from "../src/util";
 import { HASH } from "util/hash";
 
 @json
@@ -8,11 +8,6 @@ class Vec3 {
   x: i32;
   y: i32;
   z: i32;
-
-  /*@inline __JSON_Serialize(data: Vec3): string {
-    return `{"x":${data.x.toString()},"y":${data.y.toString()},"z":${data.z.toString()}}`;
-  }*/
-
   @inline __JSON_Deserialize(data: string, to: Vec3): Vec3 {
     let last = 1;
     let char = 0;
@@ -24,11 +19,11 @@ class Vec3 {
       if (inStr === false && char === quoteCode) {
         if (key != null) {
           if (unsafeCharCodeAt(key, 0) == 120) {
-            to.x = parseJSONInt<i32>(data.substring(last, pos - 1))
+            to.x = parseSciInteger<i32>(data.substring(last, pos - 1))
           } else if (unsafeCharCodeAt(key, 0) == 121) {
-            to.y = parseJSONInt<i32>(data.substring(last, pos - 1))
+            to.y = parseSciInteger<i32>(data.substring(last, pos - 1))
           } else if (unsafeCharCodeAt(key, 0) == 122) {
-            to.z = parseJSONInt<i32>(data.substring(last, pos - 1))
+            to.z = parseSciInteger<i32>(data.substring(last, pos - 1))
           }
         }
         last = ++pos;
@@ -41,11 +36,11 @@ class Vec3 {
     }
     if (key != null) {
       if (unsafeCharCodeAt(key, 0) == 120) {
-        to.x = parseJSONInt<i32>(data.substring(last, pos - 1))
+        to.x = parseSciInteger<i32>(data.substring(last, pos - 1))
       } else if (unsafeCharCodeAt(key, 0) == 121) {
-        to.y = parseJSONInt<i32>(data.substring(last, pos - 1))
+        to.y = parseSciInteger<i32>(data.substring(last, pos - 1))
       } else if (unsafeCharCodeAt(key, 0) == 122) {
-        to.z = parseJSONInt<i32>(data.substring(last, pos - 1))
+        to.z = parseSciInteger<i32>(data.substring(last, pos - 1))
       }
     }
     return to;
@@ -55,20 +50,38 @@ class Vec3 {
 const vec: Vec3 = {
   x: 3,
   y: 1,
-  z: 8
+  z: 8,
 };
 
-const vecOut = new Vec3();
+@inline function istr8<T extends number>(int: T): string {
+  if (int >= 100) {
+    const str = changetype<string>(__new(6, idof<String>()));
+    store<u16>(changetype<usize>(str), ((int / 100) % 10) + 48);
+    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48, 2);
+    store<u16>(changetype<usize>(str), (int % 10) + 48, 4);
+    return str;
+  } else if (int >= 10) {
+    const str = changetype<string>(__new(4, idof<String>()));
+    store<u16>(changetype<usize>(str), ((int / 10) % 10) + 48);
+    store<u16>(changetype<usize>(str), (int % 10) + 48, 2);
+    return str;
+  } else {
+    const str = changetype<string>(__new(2, idof<String>()));
+    store<u16>(changetype<usize>(str), (int % 10) + 48);
+    return str;
+  }
+}
 
-const i32Max = blackbox("429496729");
-/*
+bench("strint", () => {
+  blackbox<string>(istr8<i32>(123));
+})
+bench("tostr", () => {
+  blackbox<string>((<i32>123).toString());
+})
 bench("Stringify Object (Vec3)", () => {
-  blackbox<string>(vec.__JSON_Serialize(vec));
-});*/
+  blackbox<string>(vec.__JSON_Serialize());
+});
 
-bench("HASH String", () => {
-  blackbox<number>(HASH("Hello"));
-})
 // TODO: Make this allocate without crashing
 bench("Parse Object (Vec3)", () => {
   blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}', vec));
@@ -91,11 +104,11 @@ bench("Stringify String Array", () => {
 });
 
 bench("Stringify String", () => {
-  blackbox(JSON.stringify(blackbox("Hello \"World!")));
+  blackbox(JSON.stringify(blackbox('Hello "World!')));
 });
 
 bench("Parse String", () => {
-  blackbox(JSON.parse<string>(blackbox('"Hello \"World!"')));
+  blackbox(JSON.parse<string>(blackbox('"Hello "World!"')));
 });
 
 bench("Stringify Boolean", () => {
@@ -120,4 +133,4 @@ bench("Stringify Float", () => {
 
 bench("Parse Float", () => {
   blackbox(JSON.parse<f32>(blackbox("3.14")));
-});
+});

package/assembly/__tests__/as-json.spec.ts

@@ -1,5 +1,13 @@
 import { JSON } from "..";
-import { u128, u128Safe, u256, u256Safe, i128, i128Safe, i256Safe } from "as-bignum/assembly";
+import {
+  u128,
+  u128Safe,
+  u256,
+  u256Safe,
+  i128,
+  i128Safe,
+  i256Safe,
+} from "as-bignum/assembly";
 function canSerde<T>(data: T): void {
   const serialized = JSON.stringify<T>(data);
   const deserialized = JSON.stringify<T>(JSON.parse<T>(serialized));
@@ -41,11 +49,11 @@ describe("Ser/de Numbers", () => {
     canSerde<i32>(-100);
     canSerde<i64>(-101);
 
-  //  canSerde<u128>(u128.from("0"))
- //   canSerde<u128>(u128.from("100"))
-   // canSerde<u128>(u128.from("101"))
+    //  canSerde<u128>(u128.from("0"))
+    //   canSerde<u128>(u128.from("100"))
+    // canSerde<u128>(u128.from("101"))
 
-   /* canSerde<u128Safe>(u128Safe.from("0"))
+    /* canSerde<u128Safe>(u128Safe.from("0"))
     canSerde<u128Safe>(u128Safe.from("100"))
     canSerde<u128Safe>(u128Safe.from("101"))
     
@@ -102,7 +110,7 @@ describe("Ser/de Numbers", () => {
   });
 
   it("should ser/de BigInt objects", () => {
-  /*  canSerde<i32>(0);
+    /*  canSerde<i32>(0);
 
     canSerde<u32>(100);
     canSerde<u64>(101);
@@ -114,7 +122,7 @@ describe("Ser/de Numbers", () => {
     canSerde<u128>(u128.from("-100"))
     canSerde<u128>(u128.from("-101"))
 */
-  })
+  });
 });
 
 describe("Ser/de Array", () => {
@@ -178,19 +186,19 @@ describe("Ser/de Array", () => {
   });
 
   it("should ser/de object arrays", () => {
-    canSerde<Vec3[]>([{
-      x: 3.4,
-      y: 1.2,
-      z: 8.3
-    },
-    {
-      x: 3.4,
-      y: -2.1,
-      z: 9.3
-    }
+    canSerde<Vec3[]>([
+      {
+        x: 3.4,
+        y: 1.2,
+        z: 8.3,
+      },
+      {
+        x: 3.4,
+        y: -2.1,
+        z: 9.3,
+      },
     ]);
-
-  })
+  });
 });
 
 describe("Ser/de Objects", () => {
@@ -198,7 +206,7 @@ describe("Ser/de Objects", () => {
     canSerde<Vec3>({
       x: 3.4,
       y: 1.2,
-      z: 8.3
+      z: 8.3,
     });
   });
   it("should ser/de deep objects", () => {
@@ -210,9 +218,9 @@ describe("Ser/de Objects", () => {
       pos: {
         x: 3.4,
         y: 1.2,
-        z: 8.3
+        z: 8.3,
       },
       isVerified: true,
     });
   });
-});
+});

package/assembly/index.ts

@@ -1 +1 @@
-export { JSON } from "./src/json";
+export { JSON } from "./src/json";

package/assembly/src/chars.ts

@@ -26,4 +26,4 @@ export const emptyArrayWord = "[]";
 export const commaWord = ",";
 export const rightBracketWord = "]";
 // Escape Codes
-export const newLineCode = "\n".charCodeAt(0);
+export const newLineCode = "\n".charCodeAt(0);