json-as 0.9.1 → 0.9.3

package/assembly/deserialize/string.ts

@@ -1,75 +1,75 @@
 import {
-    bCode,
-    backSlashCode,
-    backspaceCode,
-    carriageReturnCode,
-    fCode,
-    formFeedCode,
-    forwardSlashCode,
-    nCode,
-    newLineCode,
-    quoteCode,
-    rCode,
-    tCode,
-    tabCode,
-    uCode
+    CHAR_B,
+    BACK_SLASH,
+    BACKSPACE,
+    CARRIAGE_RETURN,
+    CHAR_F,
+    FORM_FEED,
+    FWD_SLASH,
+    CHAR_N,
+    NEW_LINE,
+    QUOTE,
+    CHAR_R,
+    CHAR_T,
+    TAB,
+    CHAR_U
 } from "../src/chars";
 import { Sink } from "../src/sink";
 import { unsafeCharCodeAt } from "../src/util";
 
 // @ts-ignore: Decorator
-@inline export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {
+export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {
     end = end || data.length - 1;
     let result = Sink.withCapacity(end - start - 1);
     let last = start + 1;
     for (let i = last; i < end; i++) {
-        if (unsafeCharCodeAt(data, i) !== backSlashCode) {
+        if (unsafeCharCodeAt(data, i) !== BACK_SLASH) {
             continue;
         }
         const char = unsafeCharCodeAt(data, ++i);
         result.write(data, last, i - 1);
         switch (char) {
-            case quoteCode: {
-                result.writeCodePoint(quoteCode);
+            case QUOTE: {
+                result.writeCodePoint(QUOTE);
                 last = i + 1;
                 break;
             }
-            case backSlashCode: {
-                result.writeCodePoint(backSlashCode);
+            case BACK_SLASH: {
+                result.writeCodePoint(BACK_SLASH);
                 last = i + 1;
                 break;
             }
-            case forwardSlashCode: {
-                result.writeCodePoint(forwardSlashCode);
+            case FWD_SLASH: {
+                result.writeCodePoint(FWD_SLASH);
                 last = i + 1;
                 break;
             }
-            case bCode: {
-                result.writeCodePoint(backspaceCode);
+            case CHAR_B: {
+                result.writeCodePoint(BACKSPACE);
                 last = i + 1;
                 break;
             }
-            case fCode: {
-                result.writeCodePoint(formFeedCode);
+            case CHAR_F: {
+                result.writeCodePoint(FORM_FEED);
                 last = i + 1;
                 break;
             }
-            case nCode: {
-                result.writeCodePoint(newLineCode);
+            case CHAR_N: {
+                result.writeCodePoint(NEW_LINE);
                 last = i + 1;
                 break;
             }
-            case rCode: {
-                result.writeCodePoint(carriageReturnCode);
+            case CHAR_R: {
+                result.writeCodePoint(CARRIAGE_RETURN);
                 last = i + 1;
                 break;
             }
-            case tCode: {
-                result.writeCodePoint(tabCode);
+            case CHAR_T: {
+                result.writeCodePoint(TAB);
                 last = i + 1;
                 break;
             }
-            case uCode: {
+            case CHAR_U: {
                 const code = u16.parse(data.slice(i + 1, i + 5), 16);
                 result.writeCodePoint(code);
                 i += 4;

package/assembly/index.ts

@@ -18,14 +18,195 @@ import { deserializeBox } from "./deserialize/box";
 import { deserializeObject } from "./deserialize/object";
 import { deserializeMap } from "./deserialize/map";
 import { deserializeDate } from "./deserialize/date";
-import { nullWord } from "./src/chars";
+import { FALSE_WORD, NULL_WORD, TRUE_WORD } from "./src/chars";
 import { deserializeInteger } from "./deserialize/integer";
 import { deserializeString } from "./deserialize/string";
+import { Sink } from "./src/sink";
+import { Variant } from "as-variant/assembly";
+
+/**
+ * Offset of the 'storage' property in the JSON.Value class.
+ */
+// @ts-ignore: Decorator valid here
+const STORAGE = offsetof<JSON.Value>("storage");
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
  */
 export namespace JSON {
+  /**
+ * Enum representing the different types supported by JSON.
+ */
+  export enum Types {
+    U8,
+    U16,
+    U32,
+    U64,
+    F32,
+    F64,
+    Bool,
+    String,
+    Struct,
+    Array
+  }
+  export class Value {
+    public type: i32;
+    public length: i32 = 0;
+
+    // @ts-ignore: storage is set directly through memory
+    private storage: u64;
+
+    private constructor() { unreachable(); }
+
+    /**
+     * Creates an JSON.Value instance from a given value.
+     * @param value - The value to be encapsulated.
+     * @returns An instance of JSON.Value.
+     */
+    static from<T>(value: T): JSON.Value {
+      if (value instanceof Variant) {
+        // Handle
+      } else if (value instanceof JSON.Value) {
+        return value;
+      }
+      const out = changetype<JSON.Value>(__new(offsetof<JSON.Value>(), idof<JSON.Value>()));
+      out.set<T>(value);
+      return out;
+    }
+
+    /**
+     * Sets the value of the JSON.Value instance.
+     * @param value - The value to be set.
+     */
+    set<T>(value: T): void {
+      if (isBoolean<T>()) {
+        this.type = JSON.Types.Bool;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof u8 || value instanceof i8) {
+        this.type = JSON.Types.U8;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof u16 || value instanceof i16) {
+        this.type = JSON.Types.U16;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof u32 || value instanceof i32) {
+        this.type = JSON.Types.U32;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof u64 || value instanceof i64) {
+        this.type = JSON.Types.U64;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof f32) {
+        this.type = JSON.Types.F64;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof f64) {
+        this.type = JSON.Types.F64;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (isString<T>()) {
+        this.type = JSON.Types.String;
+        this.length = String.UTF8.byteLength(value as string);
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (value instanceof Map) {
+        if (idof<T>() !== idof<Map<string, JSON.Value>>()) {
+          throw new Error("Maps must be of type Map<string, JSON.Value>!");
+        }
+        this.type = JSON.Types.Struct;
+        store<T>(changetype<usize>(this), value, STORAGE);
+        // @ts-ignore: __SERIALIZE is implemented by the transform
+      } else if (isDefined(value.__SERIALIZE)) {
+        this.type = JSON.Types.Struct;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      } else if (isArray<T>()) {
+        // @ts-ignore: T satisfies constraints of any[]
+        this.type = JSON.Types.Array + getArrayDepth<T>(0);
+        // @ts-ignore
+        this.length = value.length;
+        store<T>(changetype<usize>(this), value, STORAGE);
+      }
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    unwrap<T>(): T {
+      if (isManaged<T>()) {
+        if (this.type !== JSON.Types.Struct) throw new Error("Type mismatch");
+        if (idof<T>() !== load<u32>(changetype<usize>(this.storage), -8)) throw new Error("Type mismatch");
+      }
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    unwrapUnsafe<T>(): T {
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    get<T>(): T {
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    getUnsafe<T>(): T {
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    is<T>(): T {
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * Gets the value of the JSON.Value instance.
+     * @returns The encapsulated value.
+     */
+    clone<T>(): T {
+      return load<T>(changetype<usize>(this), STORAGE);
+    }
+
+    /**
+     * 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(useString: boolean = false): 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_WORD : FALSE_WORD;
+        default: {
+          const arr = this.get<JSON.Value[]>();
+          if (!arr.length) return "[]";
+          const out = Sink.fromString("[");
+          for (let i = 0; i < arr.length - 1; i++) {
+            const element = unchecked(arr[i]);
+            out.write(element.toString(useString));
+            out.write(",");
+          }
+
+          const element = unchecked(arr[arr.length - 1]);
+          out.write(element.toString(useString));
+
+          out.write("]");
+          return out.toString();
+        }
+      }
+    }
+  }
   /**
    * Stringifies valid JSON data.
    * ```js
@@ -35,16 +216,9 @@ export namespace JSON {
    * @returns string
    */
   // @ts-ignore: Decorator
-  @inline export function stringify<T>(data: T): string {
-    if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
-      return nullWord;
-      // @ts-ignore
-    } else if (isString<T>()) {
-      return serializeString(data as string);
-    } else if (isBoolean<T>()) {
+  export function stringify<T>(data: T): string {
+    if (isBoolean<T>()) {
       return serializeBool(data as bool);
-    } else if (data instanceof Box) {
-      return serializeBox(data);
     } else if (isInteger<T>()) {
       // @ts-ignore
       return serializeInteger<T>(data);
@@ -52,15 +226,27 @@ export namespace JSON {
       // @ts-ignore
       return serializeFloat<T>(data);
       // @ts-ignore: Function is generated by transform
+    } else if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
+      return NULL_WORD;
+      // @ts-ignore
+    } else if (isString<nonnull<T>>()) {
+      return serializeString(changetype<string>(data));
+    } else if (data instanceof Box) {
+      // @ts-ignore
+      return serializeBox(changetype<nonnull<T>>(data));
+      // @ts-ignore
     } else if (isDefined(data.__SERIALIZE)) {
       // @ts-ignore
-      return serializeObject(data);
+      return serializeObject(changetype<nonnull<T>>(data));
     } else if (data instanceof Date) {
-      return serializeDate(data);
+      // @ts-ignore
+      return serializeDate(changetype<nonnull<T>>(data));
     } else if (data instanceof Array) {
-      return serializeArray(data);
+      // @ts-ignore
+      return serializeArray(changetype<nonnull<T>>(data));
     } else if (data instanceof Map) {
-      return serializeMap(data);
+      // @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.`
@@ -77,31 +263,34 @@ export namespace JSON {
    */
 
   // @ts-ignore: Decorator
-  @inline export function parse<T>(data: string): T {
-    if (isString<T>()) {
-      // @ts-ignore
-      return deserializeString(data);
-    } else if (isBoolean<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>()) {
       // @ts-ignore
-      return deserializeArray<T>(data);
+      return deserializeArray<nonnull<T>>(data);
     }
-    let type: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
+    let type: nonnull<T> = changetype<nonnull<T>>(0);
     if (type instanceof Box) {
-      return deserializeBox<T>(data);
-    } else if (isNullable<T>() && data == nullWord) {
       // @ts-ignore
-      return null;
+      return deserializeBox<nonnull<T>>(data);
       // @ts-ignore
     } else if (isDefined(type.__DESERIALIZE)) {
-      return deserializeObject<T>(data.trimStart());
+      // @ts-ignore
+      return deserializeObject<nonnull<T>>(data.trimStart());
     } else if (type instanceof Map) {
-      return deserializeMap<T>(data.trimStart());
+      // @ts-ignore
+      return deserializeMap<nonnull<T>>(data.trimStart());
     } else if (type instanceof Date) {
       // @ts-ignore
       return deserializeDate(data);
@@ -113,19 +302,12 @@ export namespace JSON {
   }
 }
 
+// This allows JSON.stringify and JSON.parse to be available globally through an alias
 // @ts-ignore: Decorator
-@global @inline function __parseObjectValue<T>(data: string, initializeDefaultValues: boolean): T {
-  // @ts-ignore
-  if (isString<T>()) return data;
-  return JSON.parse<T>(data, initializeDefaultValues);
-}
-
-// Dirty fix
-// @ts-ignore: Decorator
-@global @inline function __SERIALIZE<T>(data: T): string {
+@global function __SERIALIZE<T>(data: T): string {
   return JSON.stringify(data);
 }
 // @ts-ignore: Decorator
-@global @inline function __DESERIALIZE<T>(data: string): T {
+@global function __DESERIALIZE<T>(data: string): T {
   return JSON.parse<T>(data);
 }

package/assembly/serialize/array.ts

@@ -1,52 +1,52 @@
 import { JSON } from "..";
 import {
-    commaCode,
-    commaWord,
-    emptyArrayWord,
-    leftBracketWord,
-    rightBracketCode,
-    rightBracketWord
+    COMMA,
+    COMMA_WORD,
+    EMPTY_BRACKET_WORD,
+    BRACKET_LEFT_WORD,
+    BRACKET_RIGHT,
+    BRACKET_RIGHT_WORD
 } from "../src/chars";
 import { Sink } from "../src/sink";
 import { serializeString } from "./string";
 
 // @ts-ignore
-@inline export function serializeArray<T extends any[]>(data: T): string {
+export function serializeArray<T extends any[]>(data: T): string {
     // @ts-ignore
     if (data.length == 0) {
-        return emptyArrayWord;
+        return EMPTY_BRACKET_WORD;
         // @ts-ignore
     } else if (isString<valueof<T>>()) {
-        let result = leftBracketWord;
+        let result = BRACKET_LEFT_WORD;
         // @ts-ignore
         for (let i = 0; i < data.length - 1; i++) {
             // @ts-ignore
             result += serializeString(unchecked(data[i]));
-            result += commaWord;
+            result += COMMA_WORD;
         }
         // @ts-ignore
         result += serializeString(unchecked(data[data.length - 1]));
-        result += rightBracketWord;
+        result += BRACKET_RIGHT_WORD;
         return result;
         // @ts-ignore
     } else if (isBoolean<valueof<T>>()) {
         // @ts-ignore
-        return leftBracketWord + data.join(commaWord) + rightBracketWord;
+        return BRACKET_LEFT_WORD + data.join(COMMA_WORD) + BRACKET_RIGHT_WORD;
         // @ts-ignore
     } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
         // @ts-ignore
-        return leftBracketWord + data.join(commaWord) + rightBracketWord;
+        return BRACKET_LEFT_WORD + data.join(COMMA_WORD) + BRACKET_RIGHT_WORD;
     } else {
-        let result = Sink.fromString(leftBracketWord);
+        let result = Sink.fromString(BRACKET_LEFT_WORD);
         // @ts-ignore
         for (let i = 0; i < data.length - 1; i++) {
             // @ts-ignore
             result.write(JSON.stringify(unchecked(data[i])));
-            result.writeCodePoint(commaCode);
+            result.writeCodePoint(COMMA);
         }
         // @ts-ignore
         result.write(JSON.stringify(unchecked(data[data.length - 1])));
-        result.writeCodePoint(rightBracketCode);
+        result.writeCodePoint(BRACKET_RIGHT);
         return result.toString();
     }
 }

package/assembly/serialize/bool.ts

@@ -1,4 +1,9 @@
+/**
+ * Serialize a bool to type string
+ * @param data data to serialize
+ * @returns string
+ */
 // @ts-ignore
-@inline export function serializeBool(data: bool): string {
+export function serializeBool(data: bool): string {
     return data ? "true" : "false";
 }

package/assembly/serialize/box.ts

@@ -1,10 +1,11 @@
-import { nullWord } from "../src/chars";
+import { NULL_WORD } from "../src/chars";
 import { JSON } from "..";
+import { Box } from "as-container";
 
 // @ts-ignore
-@inline export function serializeBox<T extends Box<any>>(data: T): string {
+export function serializeBox<T extends Box<any>>(data: T): string {
   if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
-    return nullWord;
+    return NULL_WORD;
   }
   return JSON.stringify(data.unwrap());
 }

package/assembly/serialize/date.ts

@@ -1,4 +1,4 @@
 // @ts-ignore
-@inline export function serializeDate(data: Date): string {
+export function serializeDate(data: Date): string {
     return `"${data.toISOString()}"`
 }

package/assembly/serialize/float.ts

@@ -1,4 +1,4 @@
 // @ts-ignore
-@inline export function serializeFloat<T extends number>(data: T): string {
+export function serializeFloat<T extends number>(data: T): string {
     return data.toString();
 }

package/assembly/serialize/integer.ts

@@ -1,5 +1,5 @@
 // @ts-ignore
-@inline export function serializeInteger<T extends number>(data: T): string {
+export function serializeInteger<T extends number>(data: T): string {
     // I have a much faster implementation of itoa that I will port over later. Its ~4x faster
     return data.toString();
 }

package/assembly/serialize/map.ts

@@ -1,24 +1,24 @@
-import { colonCode, commaCode, leftBraceWord, rightBraceCode } from "../src/chars";
+import { COLON, COMMA, BRACE_LEFT_WORD, BRACE_RIGHT } from "../src/chars";
 import { JSON } from "..";
 import { Sink } from "../src/sink";
 import { serializeString } from "./string";
 
 // @ts-ignore
-@inline export function serializeMap<T extends Map<any, any>>(data: T): string {
-    let result = Sink.fromString(leftBraceWord);
+export function serializeMap<T extends Map<any, any>>(data: T): string {
+    let result = Sink.fromString(BRACE_LEFT_WORD);
     let keys = data.keys();
     let values = data.values();
     const end = data.size - 1;
     for (let i = 0; i < end; i++) {
         result.write(serializeString(unchecked(keys[i]).toString()));
-        result.writeCodePoint(colonCode);
+        result.writeCodePoint(COLON);
         result.write(JSON.stringify(unchecked(values[i])));
-        result.writeCodePoint(commaCode);
+        result.writeCodePoint(COMMA);
     }
     result.write(serializeString(unchecked(keys[end]).toString()));
-    result.writeCodePoint(colonCode);
+    result.writeCodePoint(COLON);
     result.write(JSON.stringify(unchecked(values[end])));
 
-    result.writeCodePoint(rightBraceCode);
+    result.writeCodePoint(BRACE_RIGHT);
     return result.toString();
 }

package/assembly/serialize/object.ts

@@ -2,6 +2,6 @@ interface GeneratedInterface {
     __SERIALIZE(): string;
 }
 // @ts-ignore
-@inline export function serializeObject<T extends GeneratedInterface>(data: T): string {
+export function serializeObject<T extends GeneratedInterface>(data: T): string {
     return changetype<nonnull<T>>(data).__SERIALIZE();
 }

package/assembly/serialize/string.ts

@@ -1,23 +1,32 @@
-import { backSlashCode, backspaceCode as BACKSPACE, carriageReturnCode as CARRIAGE_RETURN, formFeedCode as FORM_FEED, newLineCode as NEWLINE, quoteCode, quoteWord, tabCode as TAB } from "../src/chars";
+import {
+    BACK_SLASH,
+    BACKSPACE,
+    CARRIAGE_RETURN,
+    FORM_FEED,
+    NEW_LINE,
+    QUOTE,
+    QUOTE_WORD,
+    TAB
+} from "../src/chars";
 import { Sink } from "../src/sink";
 import { unsafeCharCodeAt } from "../src/util";
 
 // @ts-ignore: Decorator
-@inline export function serializeString(data: string): string {
+export function serializeString(data: string): string {
     if (data.length === 0) {
-        return quoteWord + quoteWord;
+        return QUOTE_WORD + QUOTE_WORD;
     }
 
-    let result = Sink.fromString(quoteWord, data.length);
+    let result = Sink.fromString(QUOTE_WORD, data.length);
 
     let last: i32 = 0;
     for (let i = 0; i < data.length; i++) {
         const char = unsafeCharCodeAt(<string>data, i);
-        if (char === quoteCode || char === backSlashCode) {
+        if (char === QUOTE || char === BACK_SLASH) {
             result.write(<string>data, last, i);
-            result.writeCodePoint(backSlashCode);
+            result.writeCodePoint(BACK_SLASH);
             last = i;
-        } else if (char < 16) {
+        } else if (16 > char) {
             result.write(<string>data, last, i);
             last = i + 1;
             switch (char) {
@@ -29,7 +38,7 @@ import { unsafeCharCodeAt } from "../src/util";
                     result.write("\\t");
                     break;
                 }
-                case NEWLINE: {
+                case NEW_LINE: {
                     result.write("\\n");
                     break;
                 }
@@ -49,7 +58,7 @@ import { unsafeCharCodeAt } from "../src/util";
                     break;
                 }
             }
-        } else if (char < 32) {
+        } else if (32 > char) {
             result.write(<string>data, last, i);
             last = i + 1;
             // all chars 0-31 must be encoded as a four digit unicode escape sequence
@@ -59,6 +68,6 @@ import { unsafeCharCodeAt } from "../src/util";
         }
     }
     result.write(<string>data, last);
-    result.writeCodePoint(quoteCode);
+    result.writeCodePoint(QUOTE);
     return result.toString();
 }