json-as 1.0.0-alpha.4 → 1.0.0-beta.10

package/assembly/index.ts

@@ -1,5 +1,4 @@
 /// <reference path="./index.d.ts" />
-import { bs } from "../modules/as-bs";
 
 import { serializeString } from "./serialize/simple/string";
 import { serializeArray } from "./serialize/simple/array";
@@ -7,7 +6,7 @@ import { serializeMap } from "./serialize/simple/map";
 import { deserializeBoolean } from "./deserialize/simple/bool";
 import { deserializeArray } from "./deserialize/simple/array";
 import { deserializeFloat } from "./deserialize/simple/float";
-import { deserializeObject } from "./deserialize/simple/object";
+import { deserializeStruct } from "./deserialize/simple/struct";
 import { deserializeMap } from "./deserialize/simple/map";
 import { deserializeDate } from "./deserialize/simple/date";
 import { deserializeInteger } from "./deserialize/simple/integer";
@@ -20,11 +19,14 @@ import { dtoa_buffered, itoa_buffered } from "util/number";
 import { serializeBool } from "./serialize/simple/bool";
 import { serializeInteger } from "./serialize/simple/integer";
 import { serializeFloat } from "./serialize/simple/float";
-import { serializeObject } from "./serialize/simple/object";
+import { serializeStruct } from "./serialize/simple/struct";
 import { ptrToStr } from "./util/ptrToStr";
-import { bytes } from "./util";
-
-export type Raw = string;
+import { atoi, bytes } from "./util";
+import { deserializeArbitrary } from "./deserialize/simple/arbitrary";
+import { serializeObject } from "./serialize/simple/object";
+import { deserializeObject } from "./deserialize/simple/object";
+import { serializeRaw } from "./serialize/simple/raw";
+import { deserializeRaw } from "./deserialize/simple/raw";
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -49,7 +51,8 @@ export namespace JSON {
    * @param data T
    * @returns string
    */
-  export function stringify<T>(data: T, out: string | null = null): string {
+  // @ts-ignore: inline
+  @inline export function stringify<T>(data: T, out: string | null = null): string {
     if (isBoolean<T>()) {
       if (out) {
         if (<bool>data == true) {
@@ -112,6 +115,11 @@ export namespace JSON {
       serializeString(changetype<string>(data));
       return bs.out<string>();
       // @ts-ignore: Supplied by transform
+    } else if (isDefined(data.__SERIALIZE_CUSTOM)) {
+      // @ts-ignore
+      data.__SERIALIZE_CUSTOM(changetype<usize>(data));
+      return bs.out<string>();
+      // @ts-ignore: Supplied by transform
     } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
       data.__SERIALIZE(changetype<usize>(data));
@@ -132,9 +140,15 @@ export namespace JSON {
       // @ts-ignore
       serializeMap(changetype<nonnull<T>>(data));
       return bs.out<string>();
+    } else if (data instanceof JSON.Raw) {
+      serializeRaw(data);
+      return bs.out<string>();
     } else if (data instanceof JSON.Value) {
       serializeArbitrary(data);
       return bs.out<string>();
+    } else if (data instanceof JSON.Obj) {
+      serializeObject(data);
+      return bs.out<string>();
     } else if (data instanceof JSON.Box) {
       return JSON.stringify(data.value);
     } else {
@@ -150,7 +164,8 @@ export namespace JSON {
    * @param data string
    * @returns T
    */
-  export function parse<T>(data: string): T {
+  // @ts-ignore: inline
+  @inline export function parse<T>(data: string): T {
     const dataSize = bytes(data);
     const dataPtr = changetype<usize>(data);
     if (isBoolean<T>()) {
@@ -171,18 +186,34 @@ export namespace JSON {
     }
     let type: nonnull<T> = changetype<nonnull<T>>(0);
     // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE) && isDefined(type.__INITIALIZE)) {
-      const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
+    if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      const out = changetype<nonnull<T>>(0);
+      // @ts-ignore: Defined by transform
+      if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
       // @ts-ignore
-      changetype<nonnull<T>>(out).__INITIALIZE();
+      return out.__DESERIALIZE_CUSTOM(ptrToStr(dataPtr, dataPtr + dataSize));
+      // @ts-ignore: Defined by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
+      // @ts-ignore: Defined by transform
+      if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
       // @ts-ignore
-      return deserializeObject<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
+      return deserializeStruct<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
     } else if (type instanceof Map) {
       // @ts-ignore
-      return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize);
+      return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize, 0);
     } else if (type instanceof Date) {
       // @ts-ignore
       return deserializeDate(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof JSON.Raw) {
+      // @ts-ignore: type
+      return deserializeRaw(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof JSON.Value) {
+      // @ts-ignorew
+      return deserializeArbitrary(dataPtr, dataPtr + dataSize, 0);
+    } else if (type instanceof JSON.Obj) {
+      // @ts-ignore
+      return deserializeObject(dataPtr, dataPtr + dataSize, 0);
     } else if (type instanceof JSON.Box) {
       // @ts-ignore
       return new JSON.Box(parseBox(data, changetype<nonnull<T>>(0).value));
@@ -209,19 +240,41 @@ export namespace JSON {
     Struct = 11,
   }
 
-  export type Raw = string;
+  export class Raw {
+    public data: string;
+    constructor(data: string) {
+      this.data = data;
+    }
+    set(data: string): void {
+      this.data = data;
+    }
+    toString(): string {
+      return this.data;
+    }
+    // @ts-ignore: inline
+    @inline static from(data: string): JSON.Raw {
+      return new JSON.Raw(data);
+    }
+  }
 
   export class Value {
     static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
 
-    // @ts-ignore
     private storage: u64;
 
     private constructor() {
       unreachable();
     }
 
+    /**
+     * Creates an JSON.Value instance with no set value.
+     * @returns An instance of JSON.Value.
+     */
+    @inline static empty(): JSON.Value {
+      return changetype<JSON.Value>(__new(offsetof<JSON.Value>(), idof<JSON.Value>()));
+    }
+
     /**
      * Creates an JSON.Value instance from a given value.
      * @param value - The value to be encapsulated.
@@ -257,7 +310,7 @@ export namespace JSON {
         this.type = JSON.Types.U64;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f32) {
-        this.type = JSON.Types.F64;
+        this.type = JSON.Types.F32;
         store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof f64) {
         this.type = JSON.Types.F64;
@@ -265,18 +318,31 @@ export namespace JSON {
       } else if (isString<T>()) {
         this.type = JSON.Types.String;
         store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof JSON.Raw) {
+        this.type = JSON.Types.Raw;
+        store<T>(changetype<usize>(this), value, STORAGE);
       } else if (value instanceof Map) {
         if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
           abort("Maps must be of type Map<string, JSON.Value>!");
         }
         this.type = JSON.Types.Struct;
         store<T>(changetype<usize>(this), value, STORAGE);
+        // @ts-ignore: supplied by transform
+      } else if (isDefined(value.__SERIALIZE_CUSTOM)) {
+        this.type = idof<T>() + JSON.Types.Struct;
         // @ts-ignore
+        if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE_CUSTOM.index);
+        // @ts-ignore
+        store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+        // @ts-ignore: supplied by transform
       } else if (isDefined(value.__SERIALIZE)) {
         this.type = idof<T>() + JSON.Types.Struct;
         // @ts-ignore
         if (!JSON.Value.METHODS.has(idof<T>())) JSON.Value.METHODS.set(idof<T>(), value.__SERIALIZE.index);
         // @ts-ignore
+        store<usize>(changetype<usize>(this), changetype<usize>(value), STORAGE);
+      } else if (value instanceof JSON.Obj) {
+        this.type = JSON.Types.Object;
         store<T>(changetype<usize>(this), value, STORAGE);
         // @ts-ignore
       } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
@@ -308,10 +374,17 @@ export namespace JSON {
           return this.get<u32>().toString();
         case JSON.Types.U64:
           return this.get<u64>().toString();
+        case JSON.Types.F32:
+          return this.get<f32>().toString();
+        case JSON.Types.F64:
+          return this.get<f64>().toString();
         case JSON.Types.String:
           return '"' + this.get<string>() + '"';
         case JSON.Types.Bool:
           return this.get<boolean>() ? "true" : "false";
+        case JSON.Types.Raw: {
+          return this.get<JSON.Raw>().toString();
+        }
         case JSON.Types.Array: {
           const arr = this.get<JSON.Value[]>();
           if (!arr.length) return "[]";
@@ -329,15 +402,81 @@ export namespace JSON {
           out.write("]");
           return out.toString();
         }
+        case JSON.Types.Object: {
+          return JSON.stringify(this.get<JSON.Obj>());
+        }
         default: {
           const fn = JSON.Value.METHODS.get(this.type - JSON.Types.Struct);
           const value = this.get<usize>();
-          return call_indirect<string>(fn, 0, value);
+          call_indirect<void>(fn, 0, value);
+          return bs.out<string>();
         }
       }
     }
   }
 
+  export class Obj {
+    // When accessing stackSize, subtract 2
+    // @ts-ignore: type
+    private stackSize: u32 = 6;
+    // @ts-ignore: type
+    private storage: Map<string, JSON.Value> = new Map<string, JSON.Value>();
+
+    constructor() { }
+
+    // @ts-ignore: decorator
+    @inline get size(): i32 {
+      return this.storage.size;
+    }
+
+    // @ts-ignore: decorator
+    @inline set<T>(key: string, value: T): void {
+      if (!this.storage.has(key)) this.stackSize += bytes(key) + 8;
+      this.storage.set(key, JSON.Value.from<T>(value));
+    }
+
+    // @ts-ignore: decorator
+    @inline get(key: string): JSON.Value | null {
+      if (!this.storage.has(key)) return null;
+      return this.storage.get(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline has(key: string): bool {
+      return this.storage.has(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline delete(key: string): bool {
+      return this.storage.delete(key);
+    }
+
+    // @ts-ignore: decorator
+    @inline keys(): string[] {
+      return this.storage.keys();
+    }
+
+    // @ts-ignore: decorator
+    @inline values(): JSON.Value[] {
+      return this.storage.values();
+    }
+
+    // @ts-ignore: decorator
+    @inline toString(): string {
+      return JSON.stringify(this);
+    }
+
+    // @ts-ignore: decorator
+    @inline static from<T>(value: T): JSON.Obj {
+      if (value instanceof JSON.Obj) return value;
+      const out = changetype<JSON.Obj>(__new(offsetof<JSON.Obj>(), idof<JSON.Obj>()));
+
+      if (value instanceof Map) {
+
+      }
+      return out;
+    }
+  }
   /**
    * Box for primitive types
    */
@@ -345,6 +484,15 @@ export namespace JSON {
     constructor(public value: T) {
       if (!isInteger<T>() && !isFloat<T>()) ERROR("JSON.Box should only hold primitive types!");
     }
+    /**
+     * Set the internal value of Box to new value
+     * @param value T
+     * @returns this
+     */
+    @inline set(value: T): Box<T> {
+      this.value = value;
+      return this;
+    }
     /**
      * Creates a reference to a primitive type
      * This means that it can create a nullable primitive
@@ -366,7 +514,8 @@ export namespace JSON {
     }
   }
 
-  export function __serialize<T>(src: T): void {
+  // @ts-ignore: inline
+  @inline export function __serialize<T>(src: T): void {
     if (isBoolean<T>()) {
       serializeBool(src as bool);
     } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
@@ -387,9 +536,13 @@ export namespace JSON {
     } else if (isString<nonnull<T>>()) {
       serializeString(src as string);
       // @ts-ignore: Supplied by transform
+    } else if (isDefined(src.__SERIALIZE_CUSTOM)) {
+      // @ts-ignore
+      return src.__SERIALIZE_CUSTOM(changetype<nonnull<T>>(src));
+      // @ts-ignore: Supplied by transform
     } else if (isDefined(src.__SERIALIZE)) {
       // @ts-ignore
-      serializeObject(changetype<nonnull<T>>(src));
+      serializeStruct(changetype<nonnull<T>>(src));
     } else if (src instanceof Date) {
       // @ts-ignore
       serializeDate(changetype<nonnull<T>>(src));
@@ -399,20 +552,26 @@ export namespace JSON {
     } else if (src instanceof Map) {
       // @ts-ignore
       serializeMap(changetype<nonnull<T>>(src));
+    } else if (src instanceof JSON.Raw) {
+      serializeRaw(src);
     } else if (src instanceof JSON.Value) {
       serializeArbitrary(src);
+    } else if (src instanceof JSON.Obj) {
+      serializeObject(src);
     } else if (src instanceof JSON.Box) {
       __serialize(src.value);
     } else {
       throw new Error(`Could not serialize provided data. Make sure to add the correct decorators to classes.`);
     }
   }
-  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
+
+  // @ts-ignore: inline
+  @inline export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
       // @ts-ignore: type
       return deserializeBoolean(srcStart, srcEnd);
     } else if (isInteger<T>()) {
-      return deserializeInteger<T>(srcStart, srcEnd);
+      return atoi<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
       return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
@@ -423,15 +582,28 @@ export namespace JSON {
       return deserializeArray<T>(srcStart, srcEnd, dst);
     } else {
       let type: nonnull<T> = changetype<nonnull<T>>(0);
-      // @ts-ignore: declared by transform
-      if (isDefined(type.__DESERIALIZE)) {
-        return deserializeObject<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: Defined by transform
+      if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+        const out = __new(offsetof<nonnull<T>>(), idof<nonnull<T>>());
+        // @ts-ignore: Defined by transform
+        if (isDefined(type.__INITIALIZE)) changetype<nonnull<T>>(out).__INITIALIZE();
+        // @ts-ignore
+        return changetype<nonnull<T>>(out).__DESERIALIZE_CUSTOM(ptrToStr(dataPtr, dataPtr + dataSize));
+        // @ts-ignore: Defined by transform
+      } else if (isDefined(type.__DESERIALIZE)) {
+        return deserializeStruct<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Map) {
         // @ts-ignore: type
         return deserializeMap<T>(srcStart, srcEnd, dst);
       } else if (type instanceof Date) {
         // @ts-ignore: type
         return deserializeDate(srcStart, srcEnd);
+      } else if (type instanceof JSON.Raw) {
+        // @ts-ignore: type
+        return deserializeRaw(srcStart, srcEnd);
+      } else if (type instanceof JSON.Value) {
+        // @ts-ignore: type
+        return deserializeArbitrary(srcStart, srcEnd, 0);
       } else if (type instanceof JSON.Box) {
         // @ts-ignore: type
         return new JSON.Box(deserializeBox(srcStart, srcEnd, dst, changetype<nonnull<T>>(0).value));
@@ -448,4 +620,9 @@ export namespace JSON {
 
 function deserializeBox<T>(srcStart: usize, srcEnd: usize, dst: usize, ty: T): T {
   return JSON.__deserialize<T>(srcStart, srcEnd, dst);
-}
+}
+
+export function toRaw(data: string): JSON.Raw { return new JSON.Raw(data) }
+export function fromRaw(data: JSON.Raw): string { return data.data }
+
+export function toBox<T>(data: T): JSON.Box<T> { return new JSON.Box<T>(data) }

package/assembly/serialize/simd/string.ts

@@ -1,4 +1,3 @@
-import { bs } from "../../../modules/as-bs";
 import { BACK_SLASH } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";

package/assembly/serialize/simple/arbitrary.ts

@@ -1,7 +1,9 @@
 import { JSON } from "../..";
 import { serializeArray } from "./array";
 import { serializeBool } from "./bool";
+import { serializeFloat } from "./float";
 import { serializeInteger } from "./integer";
+import { serializeObject } from "./object";
 import { serializeString } from "./string";
 
 export function serializeArbitrary(src: JSON.Value): void {
@@ -18,19 +20,30 @@ export function serializeArbitrary(src: JSON.Value): void {
     case JSON.Types.U64:
       serializeInteger<u64>(src.get<u64>());
       break;
+    case JSON.Types.F32:
+      serializeFloat<f32>(src.get<f32>());
+      break;
+    case JSON.Types.F64:
+      serializeFloat<f64>(src.get<f64>());
+      break;
     case JSON.Types.String:
       serializeString(src.get<string>());
       break;
     case JSON.Types.Bool:
       serializeBool(src.get<bool>());
+      break;
     case JSON.Types.Array: {
       serializeArray(src.get<JSON.Value[]>());
       break;
     }
+    case JSON.Types.Object: {
+      serializeObject(src.get<JSON.Obj>());
+      break;
+    }
     default: {
       const fn = JSON.Value.METHODS.get(src.type - JSON.Types.Struct);
-      const value = src.get<usize>();
-      call_indirect<string>(fn, 0, value);
+      const ptr = src.get<usize>();
+      call_indirect<void>(fn, 0, ptr);
     }
   }
 }

package/assembly/serialize/simple/array.ts

@@ -1,4 +1,3 @@
-import { bs } from "../../../modules/as-bs";
 import { COMMA, BRACKET_RIGHT, BRACKET_LEFT } from "../../custom/chars";
 import { JSON } from "../..";
 

package/assembly/serialize/simple/bool.ts

@@ -1,5 +1,3 @@
-import { bs } from "../../../modules/as-bs";
-
 /**
  * Serialize a bool to type string
  * @param data data to serialize

package/assembly/serialize/simple/date.ts

@@ -1,4 +1,3 @@
-import { bs } from "../../../modules/as-bs";
 import { QUOTE } from "../../custom/chars";
 import { bytes } from "../../util/bytes";
 

package/assembly/serialize/simple/float.ts

@@ -1,5 +1,4 @@
 import { dtoa_buffered } from "util/number";
-import { bs } from "../../../modules/as-bs";
 
 export function serializeFloat<T extends number>(data: T): void {
   bs.ensureSize(64);

package/assembly/serialize/simple/integer.ts

@@ -1,5 +1,4 @@
 import { itoa_buffered } from "util/number";
-import { bs } from "../../../modules/as-bs";
 
 export function serializeInteger<T extends number>(data: T): void {
   bs.ensureSize(sizeof<T>() << 3);

package/assembly/serialize/simple/map.ts

@@ -1,6 +1,5 @@
 import { JSON } from "../..";
 import { BRACE_LEFT, BRACE_RIGHT, COLON, COMMA } from "../../custom/chars";
-import { bs } from "../../../modules/as-bs";
 
 export function serializeMap<T extends Map<any, any>>(src: T): void {
   const srcSize = src.size;

package/assembly/serialize/simple/object.ts

@@ -1,7 +1,43 @@
-interface GeneratedInterface {
-  __SERIALIZE(ptr: usize): string;
-}
+import { JSON } from "../..";
+import { BRACE_LEFT, BRACE_RIGHT, QUOTE } from "../../custom/chars";
+import { bytes } from "../../util";
 
-export function serializeObject<T extends GeneratedInterface>(data: T): void {
-  changetype<nonnull<T>>(data).__SERIALIZE(changetype<usize>(data));
-}
+export function serializeObject(data: JSON.Obj): void {
+  if (!data.size) {
+    store<u32>(bs.offset, 0);
+    bs.offset += 4;
+    return;
+  }
+
+  // This grabs `JSON.Obj.stackSize` which is private
+  bs.ensureSize(load<u32>(changetype<usize>(data), offsetof<JSON.Obj>("stackSize")) - 2);
+  const keys = data.keys();
+  const values = data.values();
+
+  // console.log(" Keys    " + keys.join(" "));
+  // console.log(" Values  " + values.map<string>(v => v.toString()).join(" "))
+
+  store<u16>(bs.offset, BRACE_LEFT);
+  bs.offset += 2;
+
+  const firstKey = unchecked(keys[0]);
+  const keySize = bytes(firstKey);
+  store<u16>(bs.offset, QUOTE);
+  memory.copy(bs.offset + 2, changetype<usize>(firstKey), keySize);
+  store<u32>(bs.offset += keySize + 2, 3801122); // ":
+  bs.offset += 4;
+  JSON.__serialize(unchecked(values[0]));
+
+  for (let i = 1; i < keys.length; i++) {
+    const key = unchecked(keys[i]);
+    const keySize = bytes(key);
+    store<u32>(bs.offset, 2228268); // ,"
+    memory.copy(bs.offset + 4, changetype<usize>(key), keySize);
+    store<u32>(bs.offset += keySize + 4, 3801122); // ":
+    bs.offset += 4;
+    JSON.__serialize(unchecked(values[i]));
+  }
+
+  store<u16>(bs.offset, BRACE_RIGHT);
+  bs.offset += 2;
+}

package/assembly/serialize/simple/raw.ts

@@ -0,0 +1,14 @@
+import { JSON } from "../..";
+import { bytes } from "../../util";
+
+/**
+ * Serialize raw data to itself
+ * @param data data to serialize
+ * @returns void
+ */
+export function serializeRaw(data: JSON.Raw): void {
+  const dataSize = bytes(data.data);
+  bs.proposeSize(dataSize);
+  memory.copy(changetype<usize>(bs.offset), changetype<usize>(data.data), dataSize);
+  bs.offset += dataSize;
+}

package/assembly/serialize/simple/string.ts

@@ -1,6 +1,5 @@
 import { _intTo16 } from "../../custom/util";
 import { bytes } from "../../util/bytes";
-import { bs } from "../../../modules/as-bs";
 import { BACK_SLASH, QUOTE } from "../../custom/chars";
 import { SERIALIZE_ESCAPE_TABLE } from "../../globals/tables";
 

package/assembly/serialize/simple/struct.ts

@@ -0,0 +1,7 @@
+interface GeneratedInterface {
+  __SERIALIZE(ptr: usize): string;
+}
+
+export function serializeStruct<T extends GeneratedInterface>(data: T): void {
+  changetype<nonnull<T>>(data).__SERIALIZE(changetype<usize>(data));
+}