json-as 0.8.6 → 0.9.0

package/assembly/__tests__/serialize.spec.ts

@@ -0,0 +1,375 @@
+import { JSON } from "..";
+import {
+  describe,
+  expect
+} from "as-test/assembly";
+
+@json
+class BaseObject {
+  a: string;
+  constructor(a: string) {
+    this.a = a;
+  }
+}
+
+@json
+class DerivedObject extends BaseObject {
+  b: string;
+  constructor(a: string, b: string) {
+    super(a);
+    this.b = b;
+  }
+}
+
+@json
+class Map4 {
+  a: string;
+  b: string;
+  c: string;
+  d: string;
+}
+
+@json
+class Vec3 {
+  x: f64;
+  y: f64;
+  z: f64;
+
+  static shouldIgnore: string = "should not be serialized";
+}
+
+@json
+class Player {
+  firstName: string;
+  lastName: string;
+  lastActive: i32[];
+  age: i32;
+  pos: Vec3 | null;
+  isVerified: boolean;
+}
+
+class Nullable { }
+type Null = Nullable | null;
+
+describe("Should serialize strings", () => {
+
+  expect(
+    JSON.stringify("abcdefg")
+  ).toBe("\"abcdefg\"");
+
+  expect(
+    JSON.stringify('st"ring" w""ith quotes"')
+  ).toBe('"st\\"ring\\" w\\"\\"ith quotes\\""');
+
+  expect(
+    JSON.stringify('string \"with random spa\nces and \nnewlines\n\n\n')
+  ).toBe('"string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"');
+
+  expect(
+    JSON.stringify('string with colon : comma , brace [ ] bracket { } and quote " and other quote \\"')
+  ).toBe('"string with colon : comma , brace [ ] bracket { } and quote \\" and other quote \\\\\\""')
+
+});
+
+describe("Should serialize integers", () => {
+
+  expect(
+    JSON.stringify(0)
+  ).toBe("0");
+
+  expect(
+    JSON.stringify<u32>(100)
+  ).toBe("100");
+
+  expect(
+    JSON.stringify<u64>(101)
+  ).toBe("101");
+
+  expect(
+    JSON.stringify<i32>(-100)
+  ).toBe("-100");
+
+  expect(
+    JSON.stringify<i64>(-101)
+  ).toBe("-101");
+
+});
+
+describe("Should serialize floats", () => {
+
+  expect(
+    JSON.stringify<f64>(7.23)
+  ).toBe("7.23");
+
+  expect(
+    JSON.stringify<f64>(10e2)
+  ).toBe("1000.0");
+
+  expect(
+    JSON.stringify<f64>(123456e-5)
+  ).toBe("1.23456");
+
+  expect(
+    JSON.stringify<f64>(0.0)
+  ).toBe("0.0");
+
+  expect(
+    JSON.stringify<f64>(-7.23)
+  ).toBe("-7.23");
+
+  expect(
+    JSON.stringify<f64>(1e-6)
+  ).toBe("0.000001");
+
+  expect(
+    JSON.stringify<f64>(1e-7)
+  ).toBe("1e-7");
+
+  expect(
+    JSON.parse<f64>("1E-7")
+  ).toBe(1e-7);
+
+  expect(
+    JSON.stringify<f64>(1e20)
+  ).toBe("100000000000000000000.0");
+
+  expect(
+    JSON.stringify<f64>(1e21)
+  ).toBe("1e+21");
+
+  expect(
+    JSON.parse<f64>("1E+21")
+  ).toBe(1e21);
+
+  expect(
+    JSON.parse<f64>("1e21")
+  ).toBe(1e21);
+
+  expect(
+    JSON.parse<f64>("1E21")
+  ).toBe(1e21);
+
+});
+
+describe("Should serialize booleans", () => {
+
+  expect(
+    JSON.stringify<bool>(true)
+  ).toBe("true");
+
+  expect(
+    JSON.stringify<bool>(false)
+  ).toBe("false");
+
+  expect(
+    JSON.stringify<boolean>(true)
+  ).toBe("true");
+
+  expect(
+    JSON.stringify<boolean>(false)
+  ).toBe("false");
+
+});
+
+describe("Should serialize class inheritance", () => {
+
+  const obj = new DerivedObject("1", "2");
+
+  expect(
+    JSON.stringify(obj)
+  ).toBe("{\"a\":\"1\",\"b\":\"2\"}");
+
+});
+
+describe("Should serialize nulls", () => {
+
+  expect(
+    JSON.stringify<Null>(null)
+  ).toBe("null");
+
+});
+
+
+describe("Should serialize integer arrays", () => {
+
+  expect(
+    JSON.stringify<u32[]>([0, 100, 101])
+  ).toBe("[0,100,101]");
+
+  expect(
+    JSON.stringify<u64[]>([0, 100, 101])
+  ).toBe("[0,100,101]");
+
+  expect(
+    JSON.stringify<i32[]>([0, 100, 101, -100, -101])
+  ).toBe("[0,100,101,-100,-101]");
+
+  expect(
+    JSON.stringify<i64[]>([0, 100, 101, -100, -101])
+  ).toBe("[0,100,101,-100,-101]");
+
+});
+
+describe("Should serialize float arrays", () => {
+
+  expect(
+    JSON.stringify<f64[]>([7.23, 10e2, 10e2, 123456e-5, 123456e-5, 0.0, 7.23])
+  ).toBe("[7.23,1000.0,1000.0,1.23456,1.23456,0.0,7.23]");
+
+  expect(
+    JSON.stringify<f64[]>([1e21, 1e22, 1e-7, 1e-8, 1e-9])
+  ).toBe("[1e+21,1e+22,1e-7,1e-8,1e-9]");
+
+});
+
+describe("Should serialize boolean arrays", () => {
+
+  expect(
+    JSON.stringify<bool[]>([true, false])
+  ).toBe("[true,false]");
+
+  expect(
+    JSON.stringify<boolean[]>([true, false])
+  ).toBe("[true,false]");
+
+});
+
+describe("Should serialize string arrays", () => {
+
+  expect(
+    JSON.stringify<string[]>(['string \"with random spa\nces and \nnewlines\n\n\n'])
+  ).toBe('["string \\"with random spa\\nces and \\nnewlines\\n\\n\\n"]');
+
+});
+
+describe("Should serialize nested integer arrays", () => {
+
+  expect(
+    JSON.stringify<i64[][]>([[100, 101], [-100, -101], [0]])
+  ).toBe("[[100,101],[-100,-101],[0]]");
+
+});
+
+describe("Should serialize nested float arrays", () => {
+
+  expect(
+    JSON.stringify<f64[][]>([
+      [7.23],
+      [10e2],
+      [10e2],
+      [123456e-5],
+      [123456e-5],
+      [0.0],
+      [7.23],
+    ])
+  ).toBe("[[7.23],[1000.0],[1000.0],[1.23456],[1.23456],[0.0],[7.23]]");
+
+});
+
+describe("Should serialize nested boolean arrays", () => {
+
+  expect(
+    JSON.stringify<bool[][]>([[true], [false]])
+  ).toBe("[[true],[false]]");
+
+  expect(
+    JSON.stringify<boolean[][]>([[true], [false]])
+  ).toBe("[[true],[false]]");
+
+});
+
+describe("Should serialize object arrays", () => {
+
+  expect(
+    JSON.stringify<Vec3[]>([
+      {
+        x: 3.4,
+        y: 1.2,
+        z: 8.3,
+      },
+      {
+        x: 3.4,
+        y: -2.1,
+        z: 9.3,
+      },
+    ])
+  ).toBe('[{"x":3.4,"y":1.2,"z":8.3},{"x":3.4,"y":-2.1,"z":9.3}]');
+
+});
+
+describe("Ser/de Objects", () => {
+
+  expect(
+    JSON.stringify<Vec3>({
+      x: 3.4,
+      y: 1.2,
+      z: 8.3,
+    })
+  ).toBe('{"x":3.4,"y":1.2,"z":8.3}');
+
+  expect(
+    JSON.stringify<Player>({
+      firstName: "Emmet",
+      lastName: "West",
+      lastActive: [8, 27, 2022],
+      age: 23,
+      pos: {
+        x: 3.4,
+        y: 1.2,
+        z: 8.3,
+      },
+      isVerified: true,
+    })
+  ).toBe('{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
+
+  expect(
+    JSON.stringify<ObjectWithFloat>({ f: 7.23 })
+  ).toBe('{"f":7.23}');
+
+  expect(
+    JSON.stringify<ObjectWithFloat>({ f: 0.000001 })
+  ).toBe('{"f":0.000001}');
+
+  expect(
+    JSON.stringify<ObjectWithFloat>({ f: 1e-7 })
+  ).toBe('{"f":1e-7}');
+
+  expect(
+    JSON.stringify<ObjectWithFloat>({ f: 1e20 })
+  ).toBe('{"f":100000000000000000000.0}');
+
+  expect(
+    JSON.stringify<ObjectWithFloat>({ f: 1e21 })
+  ).toBe('{"f":1e+21}');
+
+  expect(
+    JSON.stringify<ObjWithStrangeKey<string>>({ data: "foo" })
+  ).toBe('{"a\\\\\\t\\"\\u0002b`c":"foo"}');
+
+});
+
+@json
+class ObjWithString {
+  s!: string;
+}
+
+@json
+class ObjectWithStringArray {
+  sa!: string[];
+}
+
+@json
+class ObjectWithFloat {
+  f!: f64;
+}
+
+@json
+class ObjectWithFloatArray {
+  fa!: f64[];
+}
+
+@json
+class ObjWithStrangeKey<T> {
+  @alias('a\\\t"\x02b`c')
+  data!: T;
+}

package/assembly/deserialize/array/array.ts

@@ -0,0 +1,31 @@
+import { leftBracketCode, rightBracketCode } from "../../src/chars";
+import { JSON } from "../..";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@inline export function deserializeArrayArray<T extends unknown[][]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let depth = 0;
+    let i = 1;
+    // Find start of bracket
+    //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
+    //i++;
+    for (; i < data.length - 1; i++) {
+        const char = unsafeCharCodeAt(data, i);
+        if (char === leftBracketCode) {
+            if (depth === 0) {
+                lastPos = i;
+            }
+            // Shifting is 6% faster than incrementing
+            depth++;
+        } else if (char === rightBracketCode) {
+            depth--;
+            if (depth === 0) {
+                i++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/bool.ts

@@ -0,0 +1,19 @@
+import { eCode, fCode, tCode } from "../../src/chars";
+import { unsafeCharCodeAt } from "../../src/util";
+import { deserializeBoolean } from "../bool";
+
+// @ts-ignore: Decorator
+@inline export function deserializeBooleanArray<T extends boolean[]>(data: string): T {
+  const result = instantiate<T>();
+  let lastPos = 1;
+  for (let i = 1; i < data.length - 1; i++) {
+    const char = unsafeCharCodeAt(data, i);
+    if (char === tCode || char === fCode) {
+      lastPos = i;
+    } else if (char === eCode) {
+      i++;
+      result.push(deserializeBoolean(data.slice(lastPos, i)));
+    }
+  }
+  return result;
+}

package/assembly/deserialize/array/float.ts

@@ -0,0 +1,24 @@
+import { isSpace } from "util/string";
+import { unsafeCharCodeAt } from "../../src/util";
+import { commaCode, rightBracketCode } from "../../src/chars";
+import { deserializeFloat } from "../float";
+
+// @ts-ignore: Decorator
+@inline export function deserializeFloatArray<T extends number[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let i = 1;
+    let awaitingParse = false;
+    for (; i < data.length; i++) {
+      const char = unsafeCharCodeAt(data, i);
+      if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
+        awaitingParse = true;
+        lastPos = i;
+      } else if (awaitingParse && (isSpace(char) || char == commaCode || char == rightBracketCode) && lastPos > 0) {
+        awaitingParse = false;
+        result.push(deserializeFloat<valueof<T>>(data.slice(lastPos, i)));
+        lastPos = 0;
+      }
+    }
+    return result;
+  }

package/assembly/deserialize/array/integer.ts

@@ -0,0 +1,24 @@
+import { isSpace } from "util/string";
+import { unsafeCharCodeAt } from "../../src/util";
+import { commaCode, rightBracketCode } from "../../src/chars";
+import { deserializeInteger } from "../integer";
+
+// @ts-ignore: Decorator
+@inline export function deserializeIntegerArray<T extends number[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos = 0;
+    let i = 1;
+    let awaitingParse = false;
+    for (; i < data.length; i++) {
+        const char = unsafeCharCodeAt(data, i);
+        if (lastPos === 0 && ((char >= 48 && char <= 57) || char === 45)) {
+            awaitingParse = true;
+            lastPos = i;
+        } else if (awaitingParse && (isSpace(char) || char == commaCode || char == rightBracketCode) && lastPos > 0) {
+            awaitingParse = false;
+            result.push(deserializeInteger<valueof<T>>(data.slice(lastPos, i)));
+            lastPos = 0;
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/map.ts

@@ -0,0 +1,27 @@
+import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { JSON } from "../..";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@inline export function deserializeMapArray<T extends unknown[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos: u32 = 1;
+    let depth: u32 = 0;
+    for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
+        const char = unsafeCharCodeAt(data, pos);
+        if (char === leftBraceCode) {
+            if (depth === 0) {
+                lastPos = pos;
+            }
+            depth++;
+        } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+                pos++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+                //lastPos = pos + 2;
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/object.ts

@@ -0,0 +1,27 @@
+import { leftBraceCode, rightBraceCode } from "../../src/chars";
+import { JSON } from "../..";
+import { unsafeCharCodeAt } from "../../src/util";
+
+// @ts-ignore: Decorator
+@inline export function deserializeObjectArray<T extends unknown[]>(data: string): T {
+    const result = instantiate<T>();
+    let lastPos: u32 = 1;
+    let depth: u32 = 0;
+    for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
+        const char = unsafeCharCodeAt(data, pos);
+        if (char === leftBraceCode) {
+            if (depth === 0) {
+                lastPos = pos;
+            }
+            depth++;
+        } else if (char === rightBraceCode) {
+            depth--;
+            if (depth === 0) {
+                pos++;
+                result.push(JSON.parse<valueof<T>>(data.slice(lastPos, pos)));
+                //lastPos = pos + 2;
+            }
+        }
+    }
+    return result;
+}

package/assembly/deserialize/array/string.ts

@@ -0,0 +1,29 @@
+import { backSlashCode, quoteCode } from "../../src/chars";
+import { unsafeCharCodeAt } from "../../src/util";
+import { deserializeString } from "../string";
+
+// @ts-ignore: Decorator
+@inline export function deserializeStringArray(data: string): string[] {
+  const result: string[] = [];
+  let lastPos = 0;
+  let instr = false;
+  let escaping = false;
+  for (let i = 1; i < data.length - 1; i++) {
+    const char = unsafeCharCodeAt(data, i);
+    if (char === backSlashCode && !escaping) {
+      escaping = true;
+    } else {
+      if (char === quoteCode && !escaping) {
+        if (instr === false) {
+          instr = true;
+          lastPos = i;
+        } else {
+          instr = false;
+          result.push(deserializeString(data, lastPos, i));
+        }
+      }
+      escaping = false;
+    }
+  }
+  return result;
+}

package/assembly/deserialize/array.ts

@@ -0,0 +1,37 @@
+import { isMap } from "../src/util";
+import { deserializeArrayArray } from "./array/array";
+import { deserializeBooleanArray } from "./array/bool";
+import { deserializeFloatArray } from "./array/float";
+import { deserializeIntegerArray } from "./array/integer";
+import { deserializeMapArray } from "./array/map";
+import { deserializeObjectArray } from "./array/object";
+import { deserializeStringArray } from "./array/string";
+
+// @ts-ignore: Decorator
+@inline export function deserializeArray<T extends unknown[]>(data: string): T {
+    if (isString<valueof<T>>()) {
+        return <T>deserializeStringArray(data);
+    } else if (isBoolean<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeBooleanArray<T>(data);
+    } else if (isInteger<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeIntegerArray<T>(data);
+    } else if (isFloat<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeFloatArray<T>(data);
+    } else if (isArrayLike<valueof<T>>()) {
+        // @ts-ignore
+        return deserializeArrayArray<T>(data);
+    } else if (isMap<valueof<T>>()) {
+        return deserializeMapArray<T>(data);
+    } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+        const type = changetype<nonnull<valueof<T>>>(0);
+        // @ts-ignore
+        if (isDefined(type.__DESERIALIZE)) {
+            return deserializeObjectArray<T>(data);
+        }
+    }
+
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+}

package/assembly/deserialize/bool.ts

@@ -0,0 +1,18 @@
+import { fCode, tCode } from "../src/chars";
+import { unsafeCharCodeAt } from "../src/util";
+
+/**
+ * Deserialize a string to type boolean
+ * @param data data to parse
+ * @returns boolean
+ */
+// @ts-ignore: Decorator
+@inline export function deserializeBoolean(data: string, start: i32 = 0, end: i32 = 0): boolean {
+    if (!end) end = data.length;
+    const len = end - start;
+    const ptr = changetype<usize>(data) + <usize>(start << 1);
+    const firstChar = unsafeCharCodeAt(data, start);
+    if (len === 4 && firstChar === tCode && load<u64>(ptr) === 28429475166421108) return true;
+    else if (len === 5 && firstChar === fCode && load<u64>(ptr, 2) === 28429466576093281) return false;
+    return false//ERROR(`Expected to find boolean, but found "${data.slice(0, 100)}" instead!`);
+}

package/assembly/deserialize/box.ts

@@ -0,0 +1,17 @@
+import { JSON } from "..";
+
+// @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);
+    // @ts-ignore
+    return changetype<T>(instance);
+}
+
+@inline function parseDirectInference<T>(type: T, data: string, initializeDefaultValues: boolean = false): T {
+    return JSON.parse<T>(data, initializeDefaultValues)
+}

package/assembly/deserialize/date.ts

@@ -0,0 +1,11 @@
+// @ts-ignore
+@inline export function deserializeDate(dateTimeString: string): Date {
+    // Use AssemblyScript's date parser
+    const d = Date.fromString(dateTimeString);
+  
+    // Return a new object instead of the one that the parser returned.
+    // This may seem redundant, but addreses the issue when Date
+    // is globally aliased to wasi_Date (or some other superclass).
+    return new Date(d.getTime());
+  }
+  

package/assembly/deserialize/float.ts

@@ -0,0 +1,9 @@
+// @ts-ignore: Decorator
+@inline export function deserializeFloat<T>(data: string): T {
+    // @ts-ignore
+    const type: T = 0;
+    // @ts-ignore
+    if (type instanceof f64) return f64.parse(data);
+    // @ts-ignore
+    return f32.parse(data);
+}

package/assembly/deserialize/integer.ts

@@ -0,0 +1,7 @@
+import { snip_fast } from "../src/util";
+
+// @ts-ignore: Decorator
+@inline export function deserializeInteger<T>(data: string): T {
+    // @ts-ignore
+    return snip_fast<T>(data);
+}