json-as 0.8.6 → 0.8.7

package/assembly/deserialize/map.ts

@@ -0,0 +1,182 @@
+import { Virtual } from "as-virtual/assembly";
+import { containsCodePoint, unsafeCharCodeAt } from "../src/util";
+import {
+    aCode,
+    backSlashCode,
+    colonCode,
+    commaCode,
+    eCode,
+    fCode,
+    lCode,
+    leftBraceCode,
+    leftBracketCode,
+    nCode,
+    quoteCode,
+    rCode,
+    rightBraceCode,
+    rightBracketCode,
+    sCode,
+    tCode,
+    uCode
+} from "../src/chars";
+import { deserializeBoolean } from "./bool";
+import { JSON } from "..";
+import { deserializeString } from "./string";
+import { isSpace } from "util/string";
+import { deserializeInteger } from "./integer";
+import { deserializeFloat } from "./float";
+
+// @ts-ignore: Decorator
+@inline export function deserializeMap<T extends Map>(data: string): T {
+
+    const map: nonnull<T> = changetype<nonnull<T>>(
+        __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
+    );
+
+    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;
+                        map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(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;
+                        map.set(deserializeMapKey<indexof<T>>(key), JSON.parse<valueof<T>>(data.slice(outerLoopIndex, objectValueIndex)));
+                        outerLoopIndex = objectValueIndex;
+                        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 {
+                            if (isString<valueof<T>>()) {
+                                const value = deserializeString(data, outerLoopIndex - 1, stringValueIndex);
+                                map.set(deserializeMapKey<indexof<T>>(key), value);
+                            }
+                            isKey = false;
+                        }
+                        outerLoopIndex = ++stringValueIndex;
+                        break;
+                    }
+                    escaping = false;
+                }
+            }
+        } else if (
+            char == nCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode) {
+            if (isNullable<valueof<T>>()) {
+                map.set(deserializeMapKey<indexof<T>>(key), null);
+            }
+            isKey = false;
+        } else if (
+            char === tCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === rCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === uCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            if (isBoolean<valueof<T>>()) {
+                map.set(deserializeMapKey<indexof<T>>(key), true);
+            }
+            isKey = false;
+        } else if (
+            char === fCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === aCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === lCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === sCode &&
+            unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+        ) {
+            if (isBoolean<valueof<T>>()) {
+                map.set(deserializeMapKey<indexof<T>>(key), false);
+            }
+            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 === colonCode || char === commaCode || char === rightBraceCode || isSpace(char)) {
+                    if (isInteger<valueof<T>>()) {
+                        map.set(deserializeMapKey<indexof<T>>(key), deserializeInteger<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
+                    } else if (isFloat<valueof<T>>()) {
+                        map.set(deserializeMapKey<indexof<T>>(key), deserializeFloat<valueof<T>>(data.slice(outerLoopIndex - 1, numberValueIndex)));
+                    }
+                    outerLoopIndex = numberValueIndex;
+                    isKey = false;
+                    break;
+                }
+            }
+        }
+    }
+
+    return map;
+}
+
+//@ts-ignore: Decorator
+@inline function deserializeMapKey<T>(key: Virtual<string>): T {
+    const k = key.copyOut();
+    if (isString<T>()) {
+        return k as T;
+    } else if (isBoolean<T>()) {
+        return deserializeBoolean(k) as T;
+    } else if (isInteger<T>()) {
+        return deserializeInteger<T>(k);
+    } else if (isFloat<T>()) {
+        return deserializeFloat<T>(k);
+    }
+
+    throw new Error(`JSON: Cannot parse JSON object to a Map with a key of type ${nameof<T>()}`);
+}

package/assembly/deserialize/object.ts

@@ -0,0 +1,136 @@
+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 { 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;
+          }
+        }
+      }
+    } 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 {
+              // @ts-ignore
+              schema.__DESERIALIZE(data, key_start, key_end, outerLoopIndex - 1, stringValueIndex + 1);
+              isKey = false;
+            }
+            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;
+        }
+      }
+    }
+  }
+  return schema;
+}

package/assembly/deserialize/string.ts

@@ -0,0 +1,88 @@
+import {
+    bCode,
+    backSlashCode,
+    backspaceCode,
+    carriageReturnCode,
+    fCode,
+    formFeedCode,
+    forwardSlashCode,
+    nCode,
+    newLineCode,
+    quoteCode,
+    rCode,
+    tCode,
+    tabCode,
+    uCode
+} 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 {
+    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) {
+            continue;
+        }
+        const char = unsafeCharCodeAt(data, ++i);
+        result.write(data, last, i - 1);
+        switch (char) {
+            case quoteCode: {
+                result.writeCodePoint(quoteCode);
+                last = i + 1;
+                break;
+            }
+            case backSlashCode: {
+                result.writeCodePoint(backSlashCode);
+                last = i + 1;
+                break;
+            }
+            case forwardSlashCode: {
+                result.writeCodePoint(forwardSlashCode);
+                last = i + 1;
+                break;
+            }
+            case bCode: {
+                result.writeCodePoint(backspaceCode);
+                last = i + 1;
+                break;
+            }
+            case fCode: {
+                result.writeCodePoint(formFeedCode);
+                last = i + 1;
+                break;
+            }
+            case nCode: {
+                result.writeCodePoint(newLineCode);
+                last = i + 1;
+                break;
+            }
+            case rCode: {
+                result.writeCodePoint(carriageReturnCode);
+                last = i + 1;
+                break;
+            }
+            case tCode: {
+                result.writeCodePoint(tabCode);
+                last = i + 1;
+                break;
+            }
+            case uCode: {
+                const code = u16.parse(data.slice(i + 1, i + 5), 16);
+                result.writeCodePoint(code);
+                i += 4;
+                last = i + 1;
+                break;
+            }
+            default: {
+                throw new Error(`JSON: Cannot parse "${data}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
+            }
+        }
+    }
+    if (end > last) {
+        result.write(data, last, end);
+    }
+    return result.toString()
+}

package/assembly/index.d.ts

@@ -13,10 +13,16 @@ 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 omitwhen(condition: string): Function;
+declare function omitif(condition: string): Function;
 
 /**
  * Property decorator that allows a field to be omitted when a property is null.

package/assembly/index.ts

@@ -1,3 +1,131 @@
 /// <reference path="./index.d.ts" />
 
-export { JSON } from "./src/json";
+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);
+}

package/assembly/serialize/array.ts

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

package/assembly/serialize/bool.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+@inline export function serializeBool(data: bool): string {
+    return data ? "true" : "false";
+}

package/assembly/serialize/box.ts

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

package/assembly/serialize/date.ts

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

package/assembly/serialize/float.ts

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

package/assembly/serialize/integer.ts

@@ -0,0 +1,5 @@
+// @ts-ignore
+@inline 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

@@ -0,0 +1,24 @@
+import { colonCode, commaCode, leftBraceWord, rightBraceCode } 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);
+    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.write(JSON.stringify(unchecked(values[i])));
+        result.writeCodePoint(commaCode);
+    }
+    result.write(serializeString(unchecked(keys[end]).toString()));
+    result.writeCodePoint(colonCode);
+    result.write(JSON.stringify(unchecked(values[end])));
+
+    result.writeCodePoint(rightBraceCode);
+    return result.toString();
+}

package/assembly/serialize/object.ts

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