json-as 0.8.7 → 0.8.8

package/assembly/deserialize/array.ts

@@ -28,7 +28,7 @@ import { deserializeStringArray } from "./array/string";
     } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
         const type = changetype<nonnull<valueof<T>>>(0);
         // @ts-ignore
-        if (isDefined(type.__DESERIALIZE)) {
+        if (isDefined(type.__JSON_Set_Key)) {
             return deserializeObjectArray<T>(data);
         }
     }

package/assembly/deserialize/box.ts

@@ -1,10 +1,7 @@
-import { JSON } from "..";
+import { JSON } from "../src/json";
 
 // @ts-ignore: Decorator
 @inline export function deserializeBox<T extends Box<any>>(data: string): T {
-    if (isNullable<T>() && data == "null") {
-        return null;
-    }
     const instance = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()))// as Box<usize>;
     const val = instance._val;
     instance._val = parseDirectInference(val, data);

package/assembly/deserialize/map.ts

@@ -20,7 +20,7 @@ import {
     uCode
 } from "../src/chars";
 import { deserializeBoolean } from "./bool";
-import { JSON } from "..";
+import { JSON } from "../src/json";
 import { deserializeString } from "./string";
 import { isSpace } from "util/string";
 import { deserializeInteger } from "./integer";

package/assembly/deserialize/object.ts

@@ -1,136 +1,139 @@
+import { Virtual } from "as-virtual/assembly";
 import { containsCodePoint, unsafeCharCodeAt } from "../src/util";
-import { aCode, backSlashCode, commaCode, eCode, fCode, lCode, leftBraceCode, leftBracketCode, nCode, quoteCode, rCode, rightBraceCode, rightBracketCode, sCode, tCode, uCode } from "../src/chars";
+import { nullWord,trueWord,falseWord,aCode, backSlashCode, commaCode, eCode, fCode, lCode, leftBraceCode, leftBracketCode, nCode, quoteCode, rCode, rightBraceCode, rightBracketCode, sCode, tCode, uCode } from "../src/chars";
+import { deserializeString } from "./string";
 import { isSpace } from "util/string";
 
 // @ts-ignore: Decorator
-@inline export function deserializeObject<T>(data: string): T {
-  const schema: nonnull<T> = changetype<nonnull<T>>(
-    __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
-  );
-
-  // @ts-ignore
-  schema.__INITIALIZE();
-
-  let key_start: i32 = 0;
-  let key_end: i32 = 0;
-  let isKey = false;
-  let depth = 0;
-  let outerLoopIndex = 1;
-  for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
-    const char = unsafeCharCodeAt(data, outerLoopIndex);
-    if (char === leftBracketCode) {
-      for (
-        let arrayValueIndex = outerLoopIndex;
-        arrayValueIndex < data.length - 1;
-        arrayValueIndex++
-      ) {
-        const char = unsafeCharCodeAt(data, arrayValueIndex);
-        if (char === leftBracketCode) {
-          depth++;
-        } else if (char === rightBracketCode) {
-          depth--;
-          if (depth === 0) {
-            ++arrayValueIndex;
-            // @ts-ignore
-            schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, arrayValueIndex);
-            outerLoopIndex = arrayValueIndex;
-            isKey = false;
-            break;
-          }
-        }
-      }
-    } else if (char === leftBraceCode) {
-      for (
-        let objectValueIndex = outerLoopIndex;
-        objectValueIndex < data.length - 1;
-        objectValueIndex++
-      ) {
-        const char = unsafeCharCodeAt(data, objectValueIndex);
-        if (char === leftBraceCode) {
-          depth++;
-        } else if (char === rightBraceCode) {
-          depth--;
-          if (depth === 0) {
-            ++objectValueIndex;
-            // @ts-ignore
-            schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, objectValueIndex);
-            outerLoopIndex = objectValueIndex;
-            isKey = false;
-            break;
+@inline export function deserializeObject<T>(data: string, initializeDefaultValues: boolean): T {
+    const schema: nonnull<T> = changetype<nonnull<T>>(
+      __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+    );
+  
+    // @ts-ignore
+    if (initializeDefaultValues) schema.__JSON_Initialize();
+  
+    const key = Virtual.createEmpty<string>();
+    let isKey = false;
+    let depth = 0;
+    let outerLoopIndex = 1;
+    for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
+      const char = unsafeCharCodeAt(data, outerLoopIndex);
+      if (char === leftBracketCode) {
+        for (
+          let arrayValueIndex = outerLoopIndex;
+          arrayValueIndex < data.length - 1;
+          arrayValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, arrayValueIndex);
+          if (char === leftBracketCode) {
+            depth++;
+          } else if (char === rightBracketCode) {
+            depth--;
+            if (depth === 0) {
+              ++arrayValueIndex;
+              // @ts-ignore
+              schema.__JSON_Set_Key(key, data, outerLoopIndex, arrayValueIndex, initializeDefaultValues);
+              outerLoopIndex = arrayValueIndex;
+              isKey = false;
+              break;
+            }
           }
         }
-      }
-    } else if (char === quoteCode) {
-      let escaping = false;
-      for (
-        let stringValueIndex = ++outerLoopIndex;
-        stringValueIndex < data.length - 1;
-        stringValueIndex++
-      ) {
-        const char = unsafeCharCodeAt(data, stringValueIndex);
-        if (char === backSlashCode && !escaping) {
-          escaping = true;
-        } else {
-          if (char === quoteCode && !escaping) {
-            if (isKey === false) {
-              key_start = outerLoopIndex;
-              key_end = stringValueIndex;
-              isKey = true;
-            } else {
+      } else if (char === leftBraceCode) {
+        for (
+          let objectValueIndex = outerLoopIndex;
+          objectValueIndex < data.length - 1;
+          objectValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, objectValueIndex);
+          if (char === leftBraceCode) {
+            depth++;
+          } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+              ++objectValueIndex;
               // @ts-ignore
-              schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex - 1, stringValueIndex + 1);
+              schema.__JSON_Set_Key(key, data, outerLoopIndex, objectValueIndex, initializeDefaultValues);
+              outerLoopIndex = objectValueIndex;
               isKey = false;
+              break;
             }
-            outerLoopIndex = ++stringValueIndex;
-            break;
           }
-          escaping = false;
         }
-      }
-    } else if (
-      char == nCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === uCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === lCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === lCode
-    ) {
-      // @ts-ignore
-      schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
-      outerLoopIndex += 3;
-      isKey = false;
-    } else if (
-      char === tCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === rCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === uCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === eCode
-    ) {
-      // @ts-ignore
-      schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 4);
-      outerLoopIndex += 3;
-      isKey = false;
-    } else if (
-      char === fCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 1) === aCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 2) === lCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 3) === sCode &&
-      unsafeCharCodeAt(data, outerLoopIndex + 4) === eCode
-    ) {
-      // @ts-ignore
-      schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex, outerLoopIndex + 5);
-      outerLoopIndex += 4;
-      isKey = false;
-    } else if ((char >= 48 && char <= 57) || char === 45) {
-      let numberValueIndex = ++outerLoopIndex;
-      for (; numberValueIndex < data.length; numberValueIndex++) {
-        const char = unsafeCharCodeAt(data, numberValueIndex);
-        if (char === commaCode || char === rightBraceCode || isSpace(char)) {
-          // @ts-ignore
-          schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex - 1, numberValueIndex);
-          outerLoopIndex = numberValueIndex;
-          isKey = false;
-          break;
+      } else if (char === quoteCode) {
+        let escaping = false;
+        for (
+          let stringValueIndex = ++outerLoopIndex;
+          stringValueIndex < data.length - 1;
+          stringValueIndex++
+        ) {
+          const char = unsafeCharCodeAt(data, stringValueIndex);
+          if (char === backSlashCode && !escaping) {
+            escaping = true;
+          } else {
+            if (char === quoteCode && !escaping) {
+              if (isKey === false) {
+                // perf: we can avoid creating a new string here if the key doesn't contain any escape sequences
+                if (containsCodePoint(data, backSlashCode, outerLoopIndex, stringValueIndex)) {
+                  key.reinst(deserializeString(data, outerLoopIndex - 1, stringValueIndex));
+                } else {
+                  key.reinst(data, outerLoopIndex, stringValueIndex);
+                }
+                isKey = true;
+              } else {
+                const value = deserializeString(data, outerLoopIndex - 1, stringValueIndex);
+                // @ts-ignore
+                schema.__JSON_Set_Key(key, value, 0, value.length, initializeDefaultValues);
+                isKey = false;
+              }
+              outerLoopIndex = ++stringValueIndex;
+              break;
+            }
+            escaping = false;
+          }
+        }
+      } else if (
+        char == nCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, nullWord, 0, 4, initializeDefaultValues);
+        isKey = false;
+      } else if (
+        char === tCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, trueWord, 0, 4, initializeDefaultValues);
+        isKey = false;
+      } else if (
+        char === fCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
+        unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+      ) {
+        // @ts-ignore
+        schema.__JSON_Set_Key(key, falseWord, 0, 5, initializeDefaultValues);
+        isKey = false;
+      } else if ((char >= 48 && char <= 57) || char === 45) {
+        let numberValueIndex = ++outerLoopIndex;
+        for (; numberValueIndex < data.length; numberValueIndex++) {
+          const char = unsafeCharCodeAt(data, numberValueIndex);
+          if (char === commaCode || char === rightBraceCode || isSpace(char)) {
+            // @ts-ignore
+            schema.__JSON_Set_Key(key, data, outerLoopIndex - 1, numberValueIndex, initializeDefaultValues);
+            outerLoopIndex = numberValueIndex;
+            isKey = false;
+            break;
+          }
         }
       }
     }
-  }
-  return schema;
-}
+    return schema;
+  }

package/assembly/index.d.ts

@@ -13,16 +13,10 @@ declare function serializable(target: any): void;
  */
 declare function alias(name: string): Function;
 
-/**
- * Property decorator that allows omits a field, making it be ignored.
- */
-declare function omit(): Function;
-
-
 /**
  * Property decorator that allows a field to be omitted when equal to an Expression.
  */
-declare function omitif(condition: string): Function;
+declare function omitwhen(condition: string): Function;
 
 /**
  * Property decorator that allows a field to be omitted when a property is null.

package/assembly/index.ts

@@ -1,131 +1,3 @@
 /// <reference path="./index.d.ts" />
 
-import { Box } from "as-container/assembly";
-
-import { serializeString } from "./serialize/string";
-import { serializeBool } from "./serialize/bool";
-import { serializeBox } from "./serialize/box";
-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 } from "./deserialize/bool";
-import { deserializeArray } from "./deserialize/array";
-import { deserializeFloat } from "./deserialize/float";
-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 { deserializeInteger } from "./deserialize/integer";
-import { deserializeString } from "./deserialize/string";
-
-/**
- * JSON Encoder/Decoder for AssemblyScript
- */
-export namespace JSON {
-  /**
-   * Stringifies valid JSON data.
-   * ```js
-   * JSON.stringify<T>(data)
-   * ```
-   * @param data T
-   * @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>()) {
-      return serializeBool(data as bool);
-    } else if (data instanceof Box) {
-      return serializeBox(data);
-    } else if (isInteger<T>()) {
-      // @ts-ignore
-      return serializeInteger<T>(data);
-    } else if (isFloat<T>(data)) {
-      // @ts-ignore
-      return serializeFloat<T>(data);
-      // @ts-ignore: Function is generated by transform
-    } else if (isDefined(data.__SERIALIZE)) {
-      // @ts-ignore
-      return serializeObject(data);
-    } else if (data instanceof Date) {
-      return serializeDate(data);
-    } else if (data instanceof Array) {
-      return serializeArray(data);
-    } else if (data instanceof Map) {
-      return serializeMap(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
-   */
-
-  // @ts-ignore: Decorator
-  @inline export function parse<T>(data: string): T {
-    if (isString<T>()) {
-      // @ts-ignore
-      return deserializeString(data);
-    } else 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 (isArray<T>()) {
-      // @ts-ignore
-      return deserializeArray<T>(data);
-    }
-    let type: nonnull<T> = changetype<nonnull<T>>(__new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
-    if (type instanceof Box) {
-      return deserializeBox<T>(data);
-    } else if (isNullable<T>() && data == nullWord) {
-      // @ts-ignore
-      return null;
-      // @ts-ignore
-    } else if (isDefined(type.__DESERIALIZE)) {
-      return deserializeObject<T>(data.trimStart());
-    } else if (type instanceof Map) {
-      return deserializeMap<T>(data.trimStart());
-    } else if (type instanceof Date) {
-      // @ts-ignore
-      return deserializeDate(data);
-    } else {
-      throw new Error(
-        `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
-      );
-    }
-  }
-}
-
-// @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 {
-  return JSON.stringify(data);
-}
-// @ts-ignore: Decorator
-@global @inline function __DESERIALIZE<T>(data: string): T {
-  return JSON.parse<T>(data);
-}
+export { JSON } from "./src/json";

package/assembly/serialize/array.ts

@@ -1,4 +1,3 @@
-import { JSON } from "..";
 import {
     commaCode,
     commaWord,
@@ -41,11 +40,11 @@ import { serializeString } from "./string";
         // @ts-ignore
         for (let i = 0; i < data.length - 1; i++) {
             // @ts-ignore
-            result.write(JSON.stringify(unchecked(data[i])));
+            result.write(__JSON_Stringify(unchecked(data[i])));
             result.writeCodePoint(commaCode);
         }
         // @ts-ignore
-        result.write(JSON.stringify(unchecked(data[data.length - 1])));
+        result.write(__JSON_Stringify(unchecked(data[data.length - 1])));
         result.writeCodePoint(rightBracketCode);
         return result.toString();
     }

package/assembly/serialize/box.ts

@@ -1,5 +1,5 @@
 import { nullWord } from "../src/chars";
-import { JSON } from "..";
+import { JSON } from "../src/json";
 
 // @ts-ignore
 @inline export function serializeBox<T extends Box<any>>(data: T): string {

package/assembly/serialize/map.ts

@@ -1,5 +1,5 @@
 import { colonCode, commaCode, leftBraceWord, rightBraceCode } from "../src/chars";
-import { JSON } from "..";
+import { JSON } from "../src/json";
 import { Sink } from "../src/sink";
 import { serializeString } from "./string";
 

package/assembly/src/json.ts

@@ -0,0 +1,124 @@
+import { Box } from "as-container/assembly";
+import { serializeString } from "../serialize/string";
+import { serializeBool } from "../serialize/bool";
+import { serializeBox } from "../serialize/box";
+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 } from "../deserialize/bool";
+import { deserializeArray } from "../deserialize/array";
+import { deserializeFloat } from "../deserialize/float";
+import { deserializeBox } from "../deserialize/box";
+import { deserializeObject } from "../deserialize/object";
+import { deserializeMap } from "../deserialize/map";
+import { deserializeDate } from "../deserialize/date";
+import { nullWord } from "./chars";
+import { deserializeInteger } from "../deserialize/integer";
+import { deserializeString } from "../deserialize/string";
+
+/**
+ * JSON Encoder/Decoder for AssemblyScript
+ */
+export namespace JSON {
+  /**
+   * Stringifies valid JSON data.
+   * ```js
+   * JSON.stringify<T>(data)
+   * ```
+   * @param data T
+   * @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>()) {
+      return serializeBool(data as bool);
+    } else if (data instanceof Box) {
+      return serializeBox(data);
+    } else if (isInteger<T>()) {
+      // @ts-ignore
+      return serializeInteger<T>(data);
+    } else if (isFloat<T>(data)) {
+      // @ts-ignore
+      return serializeFloat<T>(data);
+      // @ts-ignore: Function is generated by transform
+    } else if (isDefined(data.__SERIALIZE())) {
+      // @ts-ignore
+      return serializeObject(data);
+    } else if (data instanceof Date) {
+      return serializeDate(data);
+    } else if (data instanceof Array) {
+      return serializeArray(data);
+    } else if (data instanceof Map) {
+      return serializeMap(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
+   */
+
+  // @ts-ignore: Decorator
+  @inline export function parse<T>(data: string, initializeDefaultValues: boolean = false): T {
+    if (isString<T>()) {
+      // @ts-ignore
+      return deserializeString(data);
+    } else 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 (isArray<T>()) {
+      // @ts-ignore
+      return deserializeArray<T>(data);
+    }
+    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;
+      // @ts-ignore
+    } else if (isDefined(type.__JSON_Set_Key)) {
+      return deserializeObject<T>(data.trimStart(), initializeDefaultValues);
+    } else if (type instanceof Map) {
+      return deserializeMap<T>(data.trimStart());
+    } else if (type instanceof Date) {
+      // @ts-ignore
+      return deserializeDate(data);
+    } else {
+      throw new Error(
+        `Could not deserialize data ${data} to type ${nameof<T>()}. Make sure to add the correct decorators to classes.`
+      );
+    }
+  }
+}
+
+// @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 __JSON_Stringify<T>(data: T): string {
+  return JSON.stringify(data);
+}