json-as 0.5.4 → 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);
 

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/dynamic/dynamic.ts

@@ -1,3 +0,0 @@
-class Dynamic {
-    
-}

package/assembly/src/json.ts

@@ -1,3 +1,4 @@
+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 {
@@ -21,12 +22,12 @@ import {
     uCode,
     emptyArrayWord
 } from "./chars";
-import { unsafeCharCodeAt } from "./util";
+import { isBigNum, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
  */
-export class JSON {
+export namespace JSON {
     /**
      * Stringifies valid JSON data.
      * ```js
@@ -35,7 +36,7 @@ export class JSON {
      * @param data T
      * @returns string
      */
-    static stringify<T>(data: T): string {
+    export function stringify<T>(data: T): string {
         // String
         if (isString<T>()) {
             return '"' + (<string>data).replaceAll('"', '\\"') + '"';
@@ -77,6 +78,9 @@ export class JSON {
             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.`);
         }
@@ -89,7 +93,7 @@ export class JSON {
      * @param data string
      * @returns T
      */
-    static parse<T>(data: string): T {
+    export function parse<T>(data: string): T {
         let type!: T;
         if (isString<T>()) {
             // @ts-ignore
@@ -109,12 +113,15 @@ export class JSON {
             // @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.`);
         }
     }
-    private static parseObjectValue<T>(data: string): T {
+    function parseObjectValue<T>(data: string): T {
         let type!: T;
         if (isString<T>()) {
             // @ts-ignore
@@ -136,12 +143,44 @@ export class JSON {
             // @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
@@ -190,7 +229,7 @@ export class JSON {
 
 // @ts-ignore
 @inline
-export function parseObject<T>(data: string): T {
+    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;

package/assembly/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/package.json

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

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);