json-as 0.5.3 → 0.5.5

package/README.md

@@ -1,7 +1,10 @@
 # AS-JSON
+![AssemblyScript](https://img.shields.io/badge/AssemblyScript-blue)
+![WebAssembly](https://img.shields.io/badge/WebAssemby-purple)
 
-**JSON serializer/deserializer for AssemblyScript**
+## Features
 
+Full
 ## Installation
 
 ```bash
@@ -11,6 +14,12 @@
 ~ npm install visitor-as
 ```
 
+For arbitrary-length numbers, use
+
+```bash
+~ npm install as-bignum
+```
+
 Add the transform to your `asc` command
 
 ```bash
@@ -31,34 +40,50 @@ Or, add it to `asconfig.json`
 
 ```js
 import { JSON } from "json-as/assembly";
+import { u128 } from "as-bignum/assembly";
 
+// @ts-ignore
 @json
-class Vec2 {
-  x: f32
-  y: f32
+class Stats {
+  wins: u128
+  loss: u128
+}
+// @ts-ignore
+@json
+class Vec3 {
+  x: f32;
+  y: f32;
+  z: f32;
 }
 
+// @ts-ignore
 @json
 class Player {
-  firstName: string
-  lastName: string
-  lastActive: i32[]
-  age: i32
-  pos: Vec2
-  isVerified: boolean
+  firstName: string;
+  lastName: string;
+  lastActive: i32[];
+  age: i32;
+  pos: Vec3 | null;
+  isVerified: boolean;
+  stats: Stats
 }
 
-const data: Player = {
+const player: Player = {
   firstName: "Emmet",
   lastName: "West",
   lastActive: [8, 27, 2022],
   age: 23,
   pos: {
-    x: -3.4,
-    y: 1.2
+    x: 3.4,
+    y: 1.2,
+    z: 8.3
   },
-  isVerified: true
-}
+  isVerified: true,
+  stats: {
+    wins: u128.fromString("443"),
+    loss: u128.fromString("693")
+  }
+};
 
 const stringified = JSON.stringify<Player>(data);
 
@@ -68,9 +93,9 @@ const parsed = JSON.parse<Player>(stringified);
 
 ## Performance
 
-**Serialize Object (Vec2):** ~7.29m ops/s
+**Serialize Object (Vec2):** ~7.20m ops/s
 
-**Deserialize Object (Vec2):** ~1.36m ops/s
+**Deserialize Object (Vec2):** ~2.2m ops/s
 
 **Serialize Array (int[4]):** ~1.4m ops/s
 

package/asconfig.json

@@ -11,6 +11,8 @@
   },
   "options": {
     "transform": ["./transform"],
-    "bindings": "esm"
-  }
+    "bindings": "esm",
+    "extends": "./node_modules/@assemblyscript/wasi-shim/asconfig.json"
+  },
+  "extends": "./node_modules/@assemblyscript/wasi-shim/asconfig.json"
 }

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

@@ -1,4 +1,5 @@
 import { JSON } from "..";
+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));
@@ -39,6 +40,34 @@ describe("Ser/de Numbers", () => {
     canSerde<u64>(101);
     canSerde<i32>(-100);
     canSerde<i64>(-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("100"))
+    canSerde<u128Safe>(u128Safe.from("101"))
+    
+    canSerde<u256>(u256.fromU128(u128.from("0")))
+    canSerde<u256>(u256.fromU128(u128.from("100")))
+    canSerde<u256>(u256.fromU128(u128.from("101")))
+
+    canSerde<u256Safe>(u256Safe.fromU128(u128.from("0")))
+    canSerde<u256Safe>(u256Safe.fromU128(u128.from("100")))
+    canSerde<u256Safe>(u256Safe.fromU128(u128.from("101")))
+
+    canSerde<i128>(i128.from("0"))
+    canSerde<i128>(i128.from("100"))
+    canSerde<i128>(i128.from("101"))
+
+    canSerde<i128Safe>(i128Safe.from("0"))
+    canSerde<i128Safe>(i128Safe.from("100"))
+    canSerde<i128Safe>(i128Safe.from("101"))
+    canSerde<i128Safe>(i128Safe.from("-100"))
+    canSerde<i128Safe>(i128Safe.from("-101"))
+
+    canSerde<i256Safe>(new i256Safe(10, 11, 500, 501))
   });
 
   it("should ser/de floats", () => {
@@ -71,6 +100,21 @@ describe("Ser/de Numbers", () => {
       'string with colon : comma , brace [ ] bracket { } and quote " and other quote \\"'
     );
   });
+
+  it("should ser/de BigInt objects", () => {
+    canSerde<i32>(0);
+
+    canSerde<u32>(100);
+    canSerde<u64>(101);
+    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("-100"))
+    canSerde<u128>(u128.from("-101"))
+
+  })
 });
 
 describe("Ser/de Array", () => {

package/assembly/index.ts

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

package/assembly/{chars.ts → src/chars.ts}

@@ -1,3 +1,4 @@
+// Characters
 export const commaCode = ",".charCodeAt(0);
 export const quoteCode = '"'.charCodeAt(0);
 export const backSlashCode = "\\".charCodeAt(0);
@@ -16,3 +17,11 @@ export const aCode = "a".charCodeAt(0);
 export const lCode = "l".charCodeAt(0);
 export const sCode = "s".charCodeAt(0);
 export const nCode = "n".charCodeAt(0);
+// Strings
+export const trueWord = "true";
+export const falseWord = "false";
+export const nullWord = "null";
+export const leftBracketWord = "[";
+export const emptyArrayWord = "[]";
+export const commaWord = ",";
+export const rightBracketWord = "]";

package/assembly/src/json.ts

@@ -0,0 +1,494 @@
+import { u128, u128Safe, u256, u256Safe, i128, i128Safe, i256Safe } from "as-bignum/assembly";
+import { StringSink } from "as-string-sink/assembly";
+import { isSpace } from "util/string";
+import {
+    backSlashCode,
+    commaCode,
+    commaWord,
+    eCode,
+    fCode,
+    leftBraceCode,
+    leftBracketCode,
+    leftBracketWord,
+    nCode,
+    nullWord,
+    quoteCode,
+    rCode,
+    rightBraceCode,
+    rightBracketCode,
+    rightBracketWord,
+    tCode,
+    trueWord,
+    uCode,
+    emptyArrayWord
+} from "./chars";
+import { isBigNum, unsafeCharCodeAt } from "./util";
+
+/**
+ * JSON Encoder/Decoder for AssemblyScript
+ */
+export namespace JSON {
+    /**
+     * Stringifies valid JSON data.
+     * ```js
+     * JSON.stringify<T>(data)
+     * ```
+     * @param data T
+     * @returns string
+     */
+    export function stringify<T>(data: T): string {
+        // String
+        if (isString<T>()) {
+            return '"' + (<string>data).replaceAll('"', '\\"') + '"';
+        }
+        // Boolean
+        else if (isBoolean<T>()) {
+            return data ? "true" : "false";
+        }
+        // Nullable
+        else if (isNullable<T>() && data == null) {
+            return "null";
+        }
+        // Integers/Floats
+        // @ts-ignore
+        else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
+            // @ts-ignore
+            return data.toString();
+        }
+        // Class-Based serialization
+        // @ts-ignore
+        else if (isDefined(data.__JSON_Serialize)) {
+            // @ts-ignore
+            //if (isNullable<T>()) return "null";
+            // @ts-ignore
+            return data.__JSON_Serialize();
+        }
+        // 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++) {
+                // @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 if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
+            // @ts-ignore
+            return data.toString();
+        } else {
+            throw new Error(`Could not serialize data of type ${nameof<T>()}. Invalid data provided.`);
+        }
+    }
+    /**
+     * Parses valid JSON strings into their original format.
+     * ```js
+     * JSON.parse<T>(data)
+     * ```
+     * @param data string
+     * @returns T
+     */
+    export function parse<T>(data: string): T {
+        let type!: T;
+        if (isString<T>()) {
+            // @ts-ignore
+            return parseString(data);
+        } else if (isBoolean<T>()) {
+            // @ts-ignore
+            return parseBoolean<T>(data);
+        } else if (isFloat<T>() || isInteger<T>()) {
+            return parseNumber<T>(data);
+        } else if (isArrayLike<T>()) {
+            // @ts-ignore
+            return parseArray<T>(data.trimStart());
+            // @ts-ignore
+        } else if (isNullable<T>() && data == "null") {
+            // @ts-ignore
+            return null;
+            // @ts-ignore
+        } else if (isDefined(type.__JSON_Set_Key)) {
+            return parseObject<T>(data.trimStart());
+        } 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>()}. Invalide data provided.`);
+        }
+    }
+    function parseObjectValue<T>(data: string): T {
+        let type!: T;
+        if (isString<T>()) {
+            // @ts-ignore
+            return data.replaceAll('\\"', '"');
+        } else if (isBoolean<T>()) {
+            // @ts-ignore
+            return parseBoolean<T>(data);
+        } else if (isFloat<T>() || isInteger<T>()) {
+            return parseNumber<T>(data);
+        } else if (isArrayLike<T>()) {
+            // @ts-ignore
+            return parseArray<T>(data);
+            // @ts-ignore
+        } else if (isNullable<T>() && data == "null") {
+            // @ts-ignore
+            return null;
+            // @ts-ignore
+        } else if (isDefined(type.__JSON_Set_Key)) {
+            // @ts-ignore
+            //if (isNullable<T>()) return null;
+            return parseObject<T>(data);
+        } else if ((isManaged<T>() || isReference<T>()) && isBigNum<T>()) {
+            // @ts-ignore
+            return parseBigNum<T>(data);
+        } else {
+            // @ts-ignore
+            //return null;
+            throw new Error(`Could not deserialize data ${data} to type ${nameof<T>()}. Invalide data provided.`)
+        }
+    }
+    /*export class Arr extends Array<Variant> {
+        public data: Variant[] = [];
+        push<T>(data: T): i32 {
+            return this.data.push(Variant.from<T>(data));
+        }
+        at<T>(index: i32): T {
+            return this.data.at(index).get<T>();
+        }
+    }*/
+}
+
+// @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 i256Safe.fromString(data);
+}
+
+// @ts-ignore
+@inline
+    function parseString(data: string): string {
+    return data.slice(1, data.length - 1).replaceAll('\\"', '"');
+}
+
+// @ts-ignore
+@inline
+    function parseBoolean<T extends boolean>(data: string): T {
+    if (data.length > 3 && data.startsWith("true")) return <T>true;
+    else if (data.length > 4 && data.startsWith("false")) return <T>false;
+    else throw new Error(`JSON: Cannot parse "${data}" as boolean`);
+}
+
+// @ts-ignore
+@inline
+    function parseNumber<T>(data: string): T {
+    let type: T;
+    // @ts-ignore
+    if (type instanceof f64) return F64.parseFloat(data);
+    // @ts-ignore
+    else if (type instanceof f32) return F32.parseFloat(data);
+    // @ts-ignore
+    else if (type instanceof u64) return U64.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u32) return U32.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u8) return U8.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof u16) return U16.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i64) return I64.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i32) return I32.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i16) return I16.parseInt(data);
+    // @ts-ignore
+    else if (type instanceof i8) return I8.parseInt(data);
+    else
+        throw new Error(
+            `JSON: Cannot parse invalid data into a number. Either "${data}" is not a valid number, or <${nameof<T>()}> is an invald number type.`
+        );
+}
+
+// @ts-ignore
+@inline
+    export function parseObject<T>(data: string): T {
+    let schema: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
+    let key = "";
+    let isKey = false;
+    let depth = 1;
+    let char = 0;
+    let outerLoopIndex = 1;
+    for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+        char = unsafeCharCodeAt(data, outerLoopIndex);
+        if (char === leftBracketCode) {
+            for (
+                let arrayValueIndex = outerLoopIndex;
+                arrayValueIndex < data.length - 1;
+                arrayValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, arrayValueIndex);
+                if (char === leftBracketCode) {
+                    depth = depth << 1;
+                } else if (char === rightBracketCode) {
+                    depth = depth >> 1;
+                    if (depth === 1) {
+                        ++arrayValueIndex;
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, arrayValueIndex));
+                        outerLoopIndex = arrayValueIndex;
+                        isKey = false;
+                        break;
+                    }
+                }
+            }
+        } else if (char === leftBraceCode) {
+            for (
+                let objectValueIndex = outerLoopIndex;
+                objectValueIndex < data.length - 1;
+                objectValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, objectValueIndex);
+                if (char === leftBraceCode) {
+                    depth = depth << 1;
+                } else if (char === rightBraceCode) {
+                    depth = depth >> 1;
+                    if (depth === 1) {
+                        ++objectValueIndex;
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, objectValueIndex));
+                        outerLoopIndex = objectValueIndex;
+                        isKey = false;
+                        break;
+                    }
+                }
+            }
+        } else if (char === quoteCode) {
+            for (
+                let stringValueIndex = ++outerLoopIndex;
+                stringValueIndex < data.length - 1;
+                stringValueIndex++
+            ) {
+                char = unsafeCharCodeAt(data, stringValueIndex);
+                if (
+                    char === quoteCode &&
+                    unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
+                ) {
+                    if (isKey === false) {
+                        key = data.slice(outerLoopIndex, stringValueIndex);
+                        isKey = true;
+                    } else {
+                        schema.__JSON_Set_Key(key, data.slice(outerLoopIndex, stringValueIndex));
+                        isKey = false;
+                    }
+                    outerLoopIndex = ++stringValueIndex;
+                    break;
+                }
+            }
+        } else if (char == nCode) {
+            schema.__JSON_Set_Key(key, nullWord);
+            isKey = false;
+        } else if (
+            char === tCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            schema.__JSON_Set_Key(key, trueWord);
+            isKey = false;
+        } else if (
+            char === fCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "a".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "l".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === "s".charCodeAt(0) &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            schema.__JSON_Set_Key(key, "false");
+            isKey = false;
+        } else if ((char >= 48 && char <= 57) || char === 45) {
+            let numberValueIndex = ++outerLoopIndex;
+            for (; numberValueIndex < data.length; numberValueIndex++) {
+                char = unsafeCharCodeAt(data, numberValueIndex);
+                if (char === commaCode || char === rightBraceCode || isSpace(char)) {
+                    schema.__JSON_Set_Key(key, data.slice(outerLoopIndex - 1, numberValueIndex));
+                    outerLoopIndex = numberValueIndex;
+                    isKey = false;
+                    break;
+                }
+            }
+        }
+    }
+    return schema;
+}
+
+// @ts-ignore
+@inline
+    // @ts-ignore
+    export function parseArray<T extends unknown[]>(data: string): T {
+    let type!: valueof<T>;
+    if (type instanceof String) {
+        return <T>parseStringArray(data);
+    } else if (isBoolean<valueof<T>>()) {
+        // @ts-ignore
+        return parseBooleanArray<T>(data);
+    } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+        // @ts-ignore
+        return parseNumberArray<T>(data);
+    } else if (isArrayLike<valueof<T>>()) {
+        // @ts-ignore
+        return parseArrayArray<T>(data);
+        // @ts-ignore
+    } else if (isDefined(type.__JSON_Set_Key)) {
+        // @ts-ignore
+        return parseObjectArray<T>(data);
+    }
+}
+
+// @ts-ignore
+@inline
+    export function parseStringArray(data: string): string[] {
+    const result: string[] = [];
+    let lastPos = 0;
+    let instr = false;
+    for (let i = 1; i < data.length - 1; i++) {
+        if (unsafeCharCodeAt(data, i) === quoteCode) {
+            if (instr === false) {
+                instr = true;
+                lastPos = i;
+            } else if (unsafeCharCodeAt(data, i - 1) !== backSlashCode) {
+                instr = false;
+                result.push(data.slice(lastPos + 1, i).replaceAll('\\"', '"'));
+            }
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseBooleanArray<T extends boolean[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 1;
+    let char = 0;
+    for (let i = 1; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        /*// if char == "t" && i+3 == "e"
+            if (char === tCode && data.charCodeAt(i + 3) === eCode) {
+              //i += 3;
+              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+2)));
+              //i++;
+            } else if (char === fCode && data.charCodeAt(i + 4) === eCode) {
+              //i += 4;
+              result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+3)));
+              //i++;
+            }*/
+        if (char === tCode || char === fCode) {
+            lastPos = i;
+        } else if (char === eCode) {
+            i++;
+            result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i)));
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseNumberArray<T extends number[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let char = 0;
+    let i = 1;
+    for (; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        if ((lastPos === 0 && char >= 48 && char <= 57) || char === 45) {
+            lastPos = i;
+        } else if ((isSpace(char) || char == commaCode) && lastPos > 0) {
+            result.push(parseNumber<valueof<T>>(data.slice(lastPos, i)));
+            lastPos = 0;
+        }
+    }
+    for (; i > lastPos - 1; i--) {
+        char = unsafeCharCodeAt(data, i);
+        if (char !== rightBracketCode) {
+            result.push(parseNumber<valueof<T>>(data.slice(lastPos, i + 1)));
+            break;
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseArrayArray<T extends unknown[][]>(data: string): T {
+    const result = instantiate<T>();
+    let char = 0;
+    let lastPos = 0;
+    let depth = 1;
+    let i = 1;
+    // Find start of bracket
+    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
+    //i++;
+    for (; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        if (char === leftBracketCode) {
+            if (depth === 1) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth = depth << 1;
+        } else if (char === rightBracketCode) {
+            depth = depth >> 1;
+            if (depth === 1) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}
+
+// @ts-ignore
+@inline
+    export function parseObjectArray<T extends unknown[][]>(data: string): T {
+    const result = instantiate<T>();
+    let char = 0;
+    let lastPos = 1;
+    let depth = 1;
+    let i = 1;
+    // Find start of bracket
+    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) { }
+    //i++;
+    for (; i < data.length - 1; i++) {
+        char = unsafeCharCodeAt(data, i);
+        if (char === leftBraceCode) {
+            if (depth === 1) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth = depth << 1;
+        } else if (char === rightBraceCode) {
+            depth = depth >> 1;
+            if (depth === 1) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}

package/assembly/{util.ts → src/util.ts}

@@ -1,6 +1,21 @@
 import { StringSink } from "as-string-sink/assembly";
 import { isSpace } from "assemblyscript/std/assembly/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
 export function unsafeCharCodeAt(data: string, pos: i32): i32 {

package/assembly/test.ts

@@ -1,8 +1,15 @@
 import "wasi";
+import { u128 } from "as-bignum/assembly";
 import {
   JSON
 } from ".";
 
+// @ts-ignore
+@json
+class Stats {
+  wins: u128
+  loss: u128
+}
 // @ts-ignore
 @json
 class Vec3 {
@@ -20,6 +27,7 @@ class Player {
   age: i32;
   pos: Vec3 | null;
   isVerified: boolean;
+  stats: Stats
 }
 
 const player: Player = {
@@ -33,9 +41,13 @@ const player: Player = {
     z: 8.3
   },
   isVerified: true,
+  stats: {
+    wins: u128.fromString("443"),
+    loss: u128.fromString("693")
+  }
 };
 
 const serializedPlayer = JSON.stringify<Player>(player);
 console.log("Serialized Player: " + serializedPlayer);
 const deserializedPlayer = JSON.parse<Player>(serializedPlayer);
-console.log("Deserialized Player: " + JSON.stringify(deserializedPlayer));
+console.log("Deserialized Player: " + JSON.stringify(deserializedPlayer));

package/index.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -29,7 +29,8 @@
     "typescript": "^4.7.2"
   },
   "dependencies": {
-    "as-string-sink": "^0.5.0"
+    "as-string-sink": "^0.5.0",
+    "as-variant": "^0.4.0"
   },
   "repository": {
     "type": "git",

package/transform/lib/index.js

@@ -6,9 +6,10 @@ class AsJSONTransform extends ClassDecorator {
         super(...arguments);
         this.sources = [];
         this.encodeStmts = [];
-        this.decodeStmts = [];
-        this.checkDecodeStmts = [];
+        //public decodeStmts: string[] = [];
+        this.setDataStmts = [];
     }
+    //public checkDecodeStmts: string[] = [];
     visitMethodDeclaration() { }
     visitFieldDeclaration(node) {
         const lineText = toString(node);
@@ -22,9 +23,19 @@ class AsJSONTransform extends ClassDecorator {
         // @ts-ignore
         this.encodeStmts.push(`"${name}":\${JSON.stringify<${type}>(this.${name})},`);
         // @ts-ignore
-        this.decodeStmts.push(`${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`);
+        //this.decodeStmts.push(
+        //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
+        //);
         // @ts-ignore
-        this.checkDecodeStmts.push(' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n');
+        this.setDataStmts.push(`if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.${name} = JSON.parseObjectValue<${type}>(value);
+        return;
+      }
+      `);
+        // @ts-ignore
+        //this.checkDecodeStmts.push(
+        //  ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+        //);
     }
     visitClassDeclaration(node) {
         if (!node.members) {
@@ -38,7 +49,6 @@ class AsJSONTransform extends ClassDecorator {
             const stmt = this.encodeStmts[this.encodeStmts.length - 1];
             this.encodeStmts[this.encodeStmts.length - 1] = stmt.slice(0, stmt.length - 1);
             serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return \`{${this.encodeStmts.join("")}}\`;
       }
@@ -46,31 +56,50 @@ class AsJSONTransform extends ClassDecorator {
         }
         else {
             serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
         }
-        const deserializeFunc = `
-    @inline
-    __JSON_Deserialize<T>(values: Map<string, string>): T {
-        ${process.argv.includes("--debugJSON") ? this.checkDecodeStmts.join("else") : ""}
-        return {
-          ${
-        // @ts-ignore
-        this.decodeStmts.join("")}
+        /*const deserializeFunc = `
+        __JSON_Deserialize<T>(values: Map<string, string>): T {
+            ${
+              process.argv.includes("--debugJSON")
+                ? this.checkDecodeStmts.join("else")
+                : ""
+            }
+            return {
+              ${
+                // @ts-ignore
+                this.decodeStmts.join("")
+              }
+            }
         }
-    }
+        `;*/
+        const setKeyFunc = `
+      __JSON_Set_Key(key: string, value: string): void {
+        ${
+        // @ts-ignore
+        this.setDataStmts.join("")}
+        throw new Error("Cannot find key: " + key);
+      }
     `;
+        //console.log(setKeyFunc, deserializeFunc, serializeFunc)
         this.encodeStmts = [];
-        this.decodeStmts = [];
+        //this.decodeStmts = [];
+        this.setDataStmts = [];
+        //this.checkDecodeStmts = [];
         const serializedProperty = SimpleParser.parseClassMember(serializedProp, node);
         node.members.push(serializedProperty);
         const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
         node.members.push(serializeMethod);
-        const deserializeMethod = SimpleParser.parseClassMember(deserializeFunc, node);
-        node.members.push(deserializeMethod);
+        //const deserializeMethod = SimpleParser.parseClassMember(
+        //  deserializeFunc,
+        //  node
+        //);
+        //node.members.push(deserializeMethod);
+        const setDataMethod = SimpleParser.parseClassMember(setKeyFunc, node);
+        node.members.push(setDataMethod);
     }
     get name() {
         return "json";

package/transform/package.json

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

package/transform/src/index.ts

@@ -14,8 +14,9 @@ class AsJSONTransform extends ClassDecorator {
   public currentClass!: ClassDeclaration;
   public sources: Source[] = [];
   public encodeStmts: string[] = [];
-  public decodeStmts: string[] = [];
-  public checkDecodeStmts: string[] = [];
+  //public decodeStmts: string[] = [];
+  public setDataStmts: string[] = [];
+  //public checkDecodeStmts: string[] = [];
 
   visitMethodDeclaration(): void {}
   visitFieldDeclaration(node: FieldDeclaration): void {
@@ -33,14 +34,23 @@ class AsJSONTransform extends ClassDecorator {
     );
 
     // @ts-ignore
-    this.decodeStmts.push(
-      `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
-    );
+    //this.decodeStmts.push(
+   //   `${name}: JSON.parseObjectValue<${type}>(values.get("${name}")),\n`
+    //);
 
     // @ts-ignore
-    this.checkDecodeStmts.push(
-      ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+    this.setDataStmts.push(
+      `if (key.length === ${name.length} && (memory.compare(changetype<usize>("${name}"), changetype<usize>(key), ${name.length}) == 0)) {
+        this.${name} = JSON.parseObjectValue<${type}>(value);
+        return;
+      }
+      `
     );
+
+    // @ts-ignore
+    //this.checkDecodeStmts.push(
+    //  ' if (!values.has("${name}")) throw new Error("Key "${name}" was not found. Cannot instantiate object.");\n'
+    //);
   }
   visitClassDeclaration(node: ClassDeclaration): void {
     if (!node.members) {
@@ -62,21 +72,18 @@ class AsJSONTransform extends ClassDecorator {
         stmt.length - 1
       );
       serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return \`{${this.encodeStmts.join("")}}\`;
       }
       `;
     } else {
       serializeFunc = `
-      @inline
       __JSON_Serialize(): string {
         return "{}";
       }
       `;
     }
-    const deserializeFunc = `
-    @inline
+    /*const deserializeFunc = `
     __JSON_Deserialize<T>(values: Map<string, string>): T {
         ${
           process.argv.includes("--debugJSON")
@@ -90,9 +97,21 @@ class AsJSONTransform extends ClassDecorator {
           }
         }
     }
-    `;
+    `;*/
+    const setKeyFunc = `
+      __JSON_Set_Key(key: string, value: string): void {
+        ${
+        // @ts-ignore
+        this.setDataStmts.join("")
+        }
+        throw new Error("Cannot find key: " + key);
+      }
+    `
+    //console.log(setKeyFunc, deserializeFunc, serializeFunc)
     this.encodeStmts = [];
-    this.decodeStmts = [];
+    //this.decodeStmts = [];
+    this.setDataStmts = [];
+    //this.checkDecodeStmts = [];
     const serializedProperty = SimpleParser.parseClassMember(
       serializedProp,
       node
@@ -102,11 +121,16 @@ class AsJSONTransform extends ClassDecorator {
     const serializeMethod = SimpleParser.parseClassMember(serializeFunc, node);
     node.members.push(serializeMethod);
 
-    const deserializeMethod = SimpleParser.parseClassMember(
-      deserializeFunc,
+    //const deserializeMethod = SimpleParser.parseClassMember(
+    //  deserializeFunc,
+    //  node
+    //);
+    //node.members.push(deserializeMethod);
+    const setDataMethod = SimpleParser.parseClassMember(
+      setKeyFunc,
       node
     );
-    node.members.push(deserializeMethod);
+    node.members.push(setDataMethod);
   }
   get name(): string {
     return "json";

package/tests/index.js

@@ -1,4 +0,0 @@
-import assert from "assert";
-import { add } from "../build/debug.js";
-assert.strictEqual(add(1, 2), 3);
-console.log("ok");

package/tests/test.js

@@ -1,17 +0,0 @@
-const fs = require("fs");
-const loader = require("@assemblyscript/loader");
-const { WASI } = require("wasi");
-const ConsoleImport = require('as-console/imports')
-const Console = new ConsoleImport()
-const wasiOptions = {};
-const wasi = new WASI(wasiOptions);
-const imports = {
-  wasi_snapshot_preview1: wasi.wasiImport,
-  ...Console.wasmImports
-};
-const wasmModule = loader.instantiateSync(
-  fs.readFileSync(__dirname + "/output/test.wasm"),
-  imports
-);
-Console.wasmExports = wasmModule.exports
-wasi.start(wasmModule);