json-as 0.9.28 → 1.0.0-alpha.1

package/assembly/index.ts

@@ -1,23 +1,31 @@
 /// <reference path="./index.d.ts" />
-import { serializeString } from "./serialize/string";
-import { serializeBool } from "./serialize/bool";
-import { serializeInteger } from "./serialize/integer";
-import { serializeFloat } from "./serialize/float";
-import { serializeObject } from "./serialize/object";
-import { serializeDate } from "./serialize/date";
-import { serializeArray } from "./serialize/array";
-import { serializeMap } from "./serialize/map";
-import { deserializeBoolean, deserializeBoolean_Safe } from "./deserialize/bool";
-import { deserializeArray, deserializeArray_Safe } from "./deserialize/array";
-import { deserializeFloat } from "./deserialize/float";
-import { deserializeObject, deserializeObject_Safe } from "./deserialize/object";
-import { deserializeMap, deserializeMap_Safe } from "./deserialize/map";
-import { deserializeDate } from "./deserialize/date";
-import { NULL_WORD } from "./custom/chars";
-import { deserializeInteger, deserializeInteger_Safe } from "./deserialize/integer";
-import { deserializeString, deserializeString_Safe } from "./deserialize/string";
+import { bs } from "../modules/bs";
+
+import { serializeString } from "./serialize/simple/string";
+import { serializeArray } from "./serialize/simple/array";
+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 { deserializeMap } from "./deserialize/simple/map";
+import { deserializeDate } from "./deserialize/simple/date";
+import { deserializeInteger } from "./deserialize/simple/integer";
+import { deserializeString } from "./deserialize/simple/string";
+import { serializeArbitrary } from "./serialize/simple/arbitrary";
+
 import { Sink } from "./custom/sink";
-import { getArrayDepth } from "./custom/util";
+import { NULL_WORD, QUOTE } from "./custom/chars";
+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 { ptrToStr } from "./util/ptrToStr";
+import { bytes } from "./util";
+import { serializeString_SIMD } from "./serialize/simd/string";
+
+export type Raw = string;
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -29,6 +37,158 @@ import { getArrayDepth } from "./custom/util";
  * JSON Encoder/Decoder for AssemblyScript
  */
 export namespace JSON {
+  /**
+   * Serializes valid JSON data
+   * ```js
+   * JSON.stringify<T>(data)
+   * ```
+   * @param data T
+   * @returns string
+   */
+  export function stringify<T>(data: T, out: string | null = null): string {
+    if (isBoolean<T>()) {
+      if (out) {
+        if (<bool>data == true) {
+          out = changetype<string>(__renew(changetype<usize>(out), 8));
+          store<u64>(changetype<usize>(out), 28429475166421108);
+        } else {
+          out = changetype<string>(__renew(changetype<usize>(out), 10));
+          store<u64>(changetype<usize>(out), 32370086184550502);
+          store<u16>(changetype<usize>(out), 101, 8);
+        }
+        return out;
+      }
+      return data ? "true" : "false";
+    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 8));
+        store<u64>(changetype<usize>(out), 30399761348886638);
+        return out;
+      }
+      return NULL_WORD;
+    } else if (isInteger<T>(data)) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), sizeof<T>() << 3));
+
+        // @ts-ignore
+        const bytes = itoa_buffered(changetype<usize>(out), data) << 1;
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
+      }
+      return data.toString();
+    } else if (isFloat<T>(data)) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 64));
+
+        // @ts-ignore
+        const bytes = dtoa_buffered(changetype<usize>(out), data) << 1;
+        return (out = changetype<string>(__renew(changetype<usize>(out), bytes)));
+      }
+      return data.toString();
+      // @ts-ignore: Function is generated by transform
+    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), 8));
+        store<u64>(changetype<usize>(out), 30399761348886638);
+        return out;
+      }
+      return NULL_WORD;
+      // @ts-ignore
+    } else if (isString<nonnull<T>>()) {
+      if (out) {
+        out = changetype<string>(__renew(changetype<usize>(out), bytes(data) + 4));
+        // const oldSize = bs.byteLength;
+        const oldBuf = bs.buffer;
+        const newSize = bytes(data) + 4;
+        const newBuf = __new(newSize, idof<string>());
+        bs.setBuffer(newBuf);
+        serializeString(changetype<string>(data));
+        bs.setBuffer(oldBuf);
+        return changetype<string>(newBuf);
+      }
+      serializeString(changetype<string>(data));
+      return bs.out<string>();
+      // @ts-ignore: Supplied by transform
+    } else if (isDefined(data.__SERIALIZE) && isDefined(data.__ALLOCATE)) {
+      // @ts-ignore
+      data.__ALLOCATE();
+      // @ts-ignore
+      data.__SERIALIZE(changetype<usize>(data));
+      return bs.out<string>();
+      // @ts-ignore: Supplied by transform
+    } else if (data instanceof Date) {
+      out = out ? changetype<string>(__renew(changetype<usize>(out), 52)) : changetype<string>(__new(52, idof<string>()));
+
+      store<u16>(changetype<usize>(out), QUOTE);
+      memory.copy(changetype<usize>(out) + 2, changetype<usize>(data.toISOString()), 48);
+      store<u16>(changetype<usize>(out), 50);
+      return out;
+    } else if (data instanceof Array) {
+      // @ts-ignore
+      serializeArray(changetype<nonnull<T>>(data));
+      return bs.out<string>();
+    } else if (data instanceof Map) {
+      // @ts-ignore
+      serializeMap(changetype<nonnull<T>>(data));
+      return bs.out<string>();
+    } else if (data instanceof JSON.Value) {
+      serializeArbitrary(data);
+      return bs.out<string>();
+    } else if (data instanceof JSON.Box) {
+      return JSON.stringify(data.value);
+    } else {
+      ERROR(`Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+    }
+  }
+
+  /**
+   * 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 {
+    const dataSize = bytes(data);
+    const dataPtr = changetype<usize>(data);
+    if (isBoolean<T>()) {
+      return deserializeBoolean(dataPtr, dataPtr + dataSize) as T;
+    } else if (isInteger<T>()) {
+      return deserializeInteger<T>(dataPtr, dataPtr + dataSize);
+    } else if (isFloat<T>()) {
+      return deserializeFloat<T>(dataPtr, dataPtr + dataSize);
+    } else if (isNullable<T>() && data.length == 4 && data == "null") {
+      // @ts-ignore
+      return null;
+    } else if (isString<T>()) {
+      // @ts-ignore
+      return deserializeString(dataPtr, dataPtr + dataSize);
+    } else if (isArray<T>()) {
+      // @ts-ignore
+      return deserializeArray<nonnull<T>>(dataPtr, dataPtr + dataSize, changetype<usize>(instantiate<T>()));
+    }
+    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>>());
+      // @ts-ignore
+      changetype<nonnull<T>>(out).__INITIALIZE();
+      // @ts-ignore
+      return deserializeObject<nonnull<T>>(dataPtr, dataPtr + dataSize, out);
+    } else if (type instanceof Map) {
+      // @ts-ignore
+      return deserializeMap<nonnull<T>>(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof Date) {
+      // @ts-ignore
+      return deserializeDate(dataPtr, dataPtr + dataSize);
+    } else if (type instanceof JSON.Box) {
+      // @ts-ignore
+      return new JSON.Box(JSON.parse<indexof<T>>(data));
+    } else {
+      ERROR(`Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`);
+    }
+  }
+
   /**
    * Enum representing the different types supported by JSON.
    */
@@ -42,17 +202,23 @@ export namespace JSON {
     F64 = 6,
     Bool = 7,
     String = 8,
-    Obj = 8,
-    Array = 9
+    Object = 9,
+    Array = 10,
+    Struct = 11,
   }
+
   export type Raw = string;
+
   export class Value {
+    static METHODS: Map<u32, u32> = new Map<u32, u32>();
     public type: i32;
 
     // @ts-ignore
     private storage: u64;
 
-    private constructor() { unreachable(); }
+    private constructor() {
+      unreachable();
+    }
 
     /**
      * Creates an JSON.Value instance from a given value.
@@ -101,11 +267,19 @@ export namespace JSON {
         if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
           abort("Maps must be of type Map<string, JSON.Value>!");
         }
-        this.type = JSON.Types.Obj;
+        this.type = JSON.Types.Struct;
+        store<T>(changetype<usize>(this), value, STORAGE);
+        // @ts-ignore
+      } 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<T>(changetype<usize>(this), value, STORAGE);
-      } else if (isArray<T>()) {
+        // @ts-ignore
+      } else if (isArray<T>() && idof<valueof<T>>() == idof<JSON.Value>()) {
         // @ts-ignore: T satisfies constraints of any[]
-        this.type = JSON.Types.Array + getArrayDepth<T>(0);
+        this.type = JSON.Types.Array;
         store<T>(changetype<usize>(this), value, STORAGE);
       }
     }
@@ -120,18 +294,23 @@ export namespace JSON {
 
     /**
      * Converts the JSON.Value to a string representation.
-     * @param useString - If true, treats Buffer as a string.
      * @returns The string representation of the JSON.Value.
      */
     toString(): string {
       switch (this.type) {
-        case JSON.Types.U8: return this.get<u8>().toString();
-        case JSON.Types.U16: return this.get<u16>().toString();
-        case JSON.Types.U32: return this.get<u32>().toString();
-        case JSON.Types.U64: return this.get<u64>().toString();
-        case JSON.Types.String: return "\"" + this.get<string>() + "\"";
-        case JSON.Types.Bool: return this.get<boolean>() ? "true" : "false";
-        default: {
+        case JSON.Types.U8:
+          return this.get<u8>().toString();
+        case JSON.Types.U16:
+          return this.get<u16>().toString();
+        case JSON.Types.U32:
+          return this.get<u32>().toString();
+        case JSON.Types.U64:
+          return this.get<u64>().toString();
+        case JSON.Types.String:
+          return '"' + this.get<string>() + '"';
+        case JSON.Types.Bool:
+          return this.get<boolean>() ? "true" : "false";
+        case JSON.Types.Array: {
           const arr = this.get<JSON.Value[]>();
           if (!arr.length) return "[]";
           const out = Sink.fromStringLiteral("[");
@@ -148,162 +327,107 @@ export namespace JSON {
           out.write("]");
           return out.toString();
         }
+        default: {
+          const fn = JSON.Value.METHODS.get(this.type - JSON.Types.Struct);
+          const value = this.get<usize>();
+          return call_indirect<string>(fn, 0, value);
+        }
       }
     }
   }
+
+  /**
+   * Box for primitive types
+   */
   export class Box<T> {
-    constructor(public value: T) { }
+    constructor(public value: T) {}
+    /**
+     * Creates a reference to a primitive type
+     * This means that it can create a nullable primitive
+     * ```js
+     * JSON.stringify<Box<i32> | null>(null);
+     * // null
+     * ```
+     * @param from T
+     * @returns Box<T>
+     */
     @inline static from<T>(value: T): Box<T> {
       return new Box(value);
     }
   }
 
-  /**
-   * Stringifies valid JSON data.
-   * ```js
-   * JSON.stringify<T>(data)
-   * ```
-   * @param data T
-   * @returns string
-   */
-  export function stringify<T>(data: T/*, options: SerializeOptions = DEFAULT_SERIALIZE_OPTIONS*/): string {
+  export function __serialize<T>(src: T): void {
     if (isBoolean<T>()) {
-      return serializeBool(data as bool);
-    } else if (isInteger<T>() && nameof<T>() == "usize" && data == 0) {
-      return NULL_WORD;
+      serializeBool(src as bool);
+    } else if (isInteger<T>() && nameof<T>() == "usize" && src == 0) {
+      bs.ensureSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
     } else if (isInteger<T>()) {
       // @ts-ignore
-      return serializeInteger<T>(data);
-    } else if (isFloat<T>(data)) {
+      serializeInteger<T>(src);
+    } else if (isFloat<T>(src)) {
       // @ts-ignore
-      return serializeFloat<T>(data);
+      serializeFloat<T>(src);
       // @ts-ignore: Function is generated by transform
-    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
-      return NULL_WORD;
-      // @ts-ignore
+    } else if (isNullable<T>() && changetype<usize>(src) == <usize>0) {
+      bs.ensureSize(8);
+      store<u64>(bs.offset, 30399761348886638);
+      bs.offset += 8;
     } else if (isString<nonnull<T>>()) {
-      return serializeString(changetype<string>(data));
+      if (ASC_FEATURE_SIMD) {
+        serializeString_SIMD(src as string);
+      } else {
+        serializeString(src as string);
+      }
       // @ts-ignore: Supplied by transform
-    } else if (isDefined(data.__SERIALIZE)) {
-      /*if (options.pretty) {
-        // @ts-ignore
-        return serializeObject_Pretty(changetype<nonnull<T>>(data));
-      }*/
-      // @ts-ignore
-      return serializeObject(changetype<nonnull<T>>(data));
-    } else if (data instanceof Date) {
-      // @ts-ignore
-      return serializeDate(changetype<nonnull<T>>(data));
-    } else if (data instanceof Array) {
-      // @ts-ignore
-      return serializeArray(changetype<nonnull<T>>(data));
-    } else if (data instanceof Map) {
-      // @ts-ignore
-      return serializeMap(changetype<nonnull<T>>(data));
-    } else {
-      throw new Error(
-        `Could not serialize data of type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
-      );
-    }
-  }
-  /**
-   * 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 {
-    if (isBoolean<T>()) {
-      return deserializeBoolean(data) as T;
-    } else if (isInteger<T>()) {
-      return deserializeInteger<T>(data);
-    } else if (isFloat<T>()) {
-      return deserializeFloat<T>(data);
-    } else if (isNullable<T>() && data.length === 4 && data == "null") {
-      // @ts-ignore
-      return null;
-    } else if (isString<T>()) {
-      // @ts-ignore
-      return deserializeString(data);
-    } else if (isArray<T>()) {
+    } else if (isDefined(src.__SERIALIZE)) {
       // @ts-ignore
-      return deserializeArray<nonnull<T>>(data);
-    }
-    let type: nonnull<T> = changetype<nonnull<T>>(0);
-    // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE)) {
+      serializeObject(changetype<nonnull<T>>(src));
+    } else if (src instanceof Date) {
       // @ts-ignore
-      return deserializeObject<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Map) {
+      serializeDate(changetype<nonnull<T>>(src));
+    } else if (src instanceof Array) {
       // @ts-ignore
-      return deserializeMap<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Date) {
+      serializeArray(changetype<nonnull<T>>(src));
+    } else if (src instanceof Map) {
       // @ts-ignore
-      return deserializeDate(data);
+      serializeMap(changetype<nonnull<T>>(src));
+    } else if (src instanceof JSON.Value) {
+      serializeArbitrary(src);
+    } else if (src instanceof JSON.Box) {
+      __serialize(src.value);
     } else {
-      throw new Error(
-        `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
-      );
+      ERROR(`Could not serialize provided data. Make sure to add the correct decorators to classes.`);
     }
   }
-  /**
-   * Parses valid JSON strings into their original format (safely).
-   * ```js
-   * JSON.parseSafe<T>(data)
-   * ```
-   * @param data string
-   * @returns T
-   */
-
-  // @ts-ignore: Decorator
-  @inline export function parseSafe<T>(data: string): T {
+  export function __deserialize<T>(srcStart: usize, srcEnd: usize, dst: usize = 0): T {
     if (isBoolean<T>()) {
-      return deserializeBoolean_Safe(data) as T;
+      // @ts-ignore: type
+      return deserializeBoolean(srcStart, srcEnd);
     } else if (isInteger<T>()) {
-      return deserializeInteger_Safe<T>(data);
+      return deserializeInteger<T>(srcStart, srcEnd);
     } else if (isFloat<T>()) {
-      return deserializeFloat<T>(data);
-    } else if (isNullable<T>() && data.length === 4 && data == "null") {
-      // @ts-ignore
-      return null;
+      return deserializeFloat<T>(srcStart, srcEnd);
     } else if (isString<T>()) {
-      // @ts-ignore
-      return deserializeString_Safe(data);
+      // @ts-ignore: type
+      return deserializeString(srcStart, srcEnd, dst);
     } else if (isArray<T>()) {
       // @ts-ignore
-      return deserializeArray_Safe<nonnull<T>>(data);
-    }
-    let type: nonnull<T> = changetype<nonnull<T>>(0);
-    // @ts-ignore: Defined by transform
-    if (isDefined(type.__DESERIALIZE)) {
-      // @ts-ignore
-      return deserializeObject_Safe<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Map) {
-      // @ts-ignore
-      return deserializeMap_Safe<nonnull<T>>(data.trimStart());
-    } else if (type instanceof Date) {
-      // @ts-ignore
-      return deserializeDate_Safe(data);
+      return deserializeArray<T>(srcStart, srcEnd, dst);
     } else {
-      throw new Error(
-        `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
-      );
+      let type: nonnull<T> = changetype<nonnull<T>>(0);
+      // @ts-ignore: declared by transform
+      if (isDefined(type.__DESERIALIZE)) {
+        return deserializeObject<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);
+      }
     }
+    throw new Error(`Could not deserialize data '${ptrToStr(srcStart, srcEnd).slice(0, 100)}' to type. Make sure to add the correct decorators to classes.`);
   }
 }
-
-// This allows JSON.stringify and JSON.parse to be available globally through an alias
-// @ts-ignore: Decorator
-@global @inline function __SERIALIZE<T>(data: T): string {
-  return JSON.stringify(data);
-}
-// @ts-ignore: Decorator
-@global @inline function __DESERIALIZE<T>(data: string): T {
-  return JSON.parse<T>(data);
-}
-// @ts-ignore: Decorator
-@global @inline function __DESERIALIZE_SAFE<T>(data: string): T {
-  return JSON.parseSafe<T>(data);
-}