json-as 0.9.17 → 0.9.19

package/assembly/__tests__/types.ts

@@ -1,27 +1,26 @@
-
 @json
 export class ObjWithString {
-    s!: string;
+  s!: string;
 }
 
 @json
 export class ObjWithStrangeKey<T> {
-    @alias('a\\\t"\x02b`c')
-    data!: T;
+  @alias('a\\\t"\x02b`c')
+  data!: T;
 }
 @json
 export class ObjectWithStringArray {
-    sa!: string[];
+  sa!: string[];
 }
 
 @json
 export class ObjectWithFloat {
-    f!: f64;
+  f!: f64;
 }
 
 @json
 export class ObjectWithFloatArray {
-    fa!: f64[];
+  fa!: f64[];
 }
 
 @json
@@ -68,7 +67,7 @@ export class Player {
   isVerified: boolean;
 }
 
-export class Nullable { }
+export class Nullable {}
 export type Null = Nullable | null;
 
 @json
@@ -78,5 +77,5 @@ export class OmitIf {
   y: i32 = -1;
   z: i32 = 1;
   @omitnull()
-  foo: string | null = null
-}
+  foo: string | null = null;
+}

package/assembly/custom/sink.ts

@@ -3,284 +3,285 @@ import { itoa_buffered, dtoa_buffered } from "util/number";
 const MIN_BUFFER_LEN = 32;
 const MIN_BUFFER_SIZE: u32 = MIN_BUFFER_LEN << 1;
 
-const NEW_LINE_CHAR: u16 = 0x0A; // \n
+const NEW_LINE_CHAR: u16 = 0x0a; // \n
 
 // @ts-ignore: decorator
 function nextPowerOf2(n: u32): u32 {
-    return 1 << 32 - clz(n - 1);
+  return 1 << (32 - clz(n - 1));
 }
 
 export class Sink {
-    public buffer!: ArrayBuffer;
-    public offset: u32 = 0;
-
-    static withCapacity(capacity: i32): Sink {
-        const sink = new Sink();
-        sink.buffer = changetype<ArrayBuffer>(__new(
-            max<u32>(MIN_BUFFER_SIZE, <u32>capacity << 1),
-            idof<ArrayBuffer>())
-        );
-        return sink;
+  public buffer!: ArrayBuffer;
+  public offset: u32 = 0;
+
+  static withCapacity(capacity: i32): Sink {
+    const sink = new Sink();
+    sink.buffer = changetype<ArrayBuffer>(
+      __new(
+        max<u32>(MIN_BUFFER_SIZE, (<u32>capacity) << 1),
+        idof<ArrayBuffer>(),
+      ),
+    );
+    return sink;
+  }
+
+  static fromString(
+    initial: string = "",
+    capacity: i32 = MIN_BUFFER_LEN,
+  ): Sink {
+    const sink = new Sink();
+    const size = (<u32>initial.length) << 1;
+    sink.buffer = changetype<ArrayBuffer>(
+      __new(
+        max<u32>(size, max<u32>(MIN_BUFFER_SIZE, (<u32>capacity) << 1)),
+        idof<ArrayBuffer>(),
+      ),
+    );
+    if (size) {
+      memory.copy(
+        changetype<usize>(sink.buffer),
+        changetype<usize>(initial),
+        size,
+      );
+      sink.offset += size;
     }
-
-    static fromString(initial: string = "", capacity: i32 = MIN_BUFFER_LEN): Sink {
-        const sink = new Sink();
-        const size = <u32>initial.length << 1;
-        sink.buffer = changetype<ArrayBuffer>(__new(
-            max<u32>(size, max<u32>(MIN_BUFFER_SIZE, <u32>capacity << 1)),
-            idof<ArrayBuffer>())
-        );
-        if (size) {
-            memory.copy(
-                changetype<usize>(sink.buffer),
-                changetype<usize>(initial),
-                size
-            );
-            sink.offset += size;
-        }
-        return sink;
-    }
-
-    static fromStringLiteral(initial: string = ""): Sink {
-        const sink = new Sink();
-        const size = <u32>initial.length << 1;
-        sink.buffer = changetype<ArrayBuffer>(__new(
-            size,
-            idof<ArrayBuffer>())
-        );
-        if (size) {
-            memory.copy(
-                changetype<usize>(sink.buffer),
-                changetype<usize>(initial),
-                size
-            );
-            sink.offset += size;
-        }
-        return sink;
-    }
-
-    static fromBuffer(initial: ArrayBuffer, capacity: i32 = MIN_BUFFER_LEN): Sink {
-        const sink = new Sink();
-        const size = <u32>initial.byteLength;
-        sink.buffer = changetype<ArrayBuffer>(__new(
-            max<u32>(size, max<u32>(MIN_BUFFER_SIZE, <u32>capacity << 1)),
-            idof<ArrayBuffer>())
-        );
-        if (size) {
-            memory.copy(
-                changetype<usize>(sink.buffer),
-                changetype<usize>(initial),
-                size
-            );
-            sink.offset = size;
-        }
-        return sink;
-    }
-
-    constructor() { }
-
-    get length(): i32 {
-        return this.offset >> 1;
-    }
-
-    get capacity(): i32 {
-        return this.buffer.byteLength >>> 1;
-    }
-    reset(): void {
-        this.offset = 0;
-    }
-    write(src: string, start: i32 = 0, end: i32 = i32.MAX_VALUE): Sink | null {
-        let len = src.length as u32;
-
-        if (start != 0 || end != i32.MAX_VALUE) {
-            let from: i32;
-            from = min<i32>(max(start, 0), len);
-            end = min<i32>(max(end, 0), len);
-            start = min<i32>(from, end);
-            end = max<i32>(from, end);
-            len = end - start;
-        }
-
-        if (!len) return null;
-
-        let size = len << 1;
-        this.ensureCapacity(size);
-        let offset = this.offset;
-
-        memory.copy(
-            changetype<usize>(this.buffer) + offset,
-            changetype<usize>(src) + (<usize>start << 1),
-            size
-        );
-        this.offset = offset + size;
-        return this;
-    }
-
-    writeLn(src: string = "", start: i32 = 0, end: i32 = i32.MAX_VALUE): Sink {
-        let len = src.length as u32;
-        if (start != 0 || end != i32.MAX_VALUE) {
-            let from: i32;
-            from = min<i32>(max(start, 0), len);
-            end = min<i32>(max(end, 0), len);
-            start = min<i32>(from, end);
-            end = max<i32>(from, end);
-            len = end - start;
-        }
-
-        let size = len << 1;
-        this.ensureCapacity(size + 2);
-        let offset = this.offset;
-        let dest = changetype<usize>(this.buffer) + offset;
-        if (size) memory.copy(dest, changetype<usize>(src) + (<usize>start << 1), size);
-        store<u16>(dest + size, NEW_LINE_CHAR);
-        this.offset = offset + (size + 2);
-        return this;
-    }
-
-    writeCodePoint(code: i32): Sink {
-        let hasSur = <u32>code > 0xFFFF;
-        this.ensureCapacity(2 << i32(hasSur));
-
-        let offset = this.offset;
-        let dest = changetype<usize>(this.buffer) + offset;
-
-        if (!hasSur) {
-            store<u16>(dest, <u16>code);
-            this.offset = offset + 2;
-        } else {
-            assert(<u32>code <= 0x10FFFF);
-            code -= 0x10000;
-            let hi = (code & 0x03FF) | 0xDC00;
-            let lo = code >>> 10 | 0xD800;
-            store<u32>(dest, lo | hi << 16);
-            this.offset = offset + 4;
-        }
-        return this;
+    return sink;
+  }
+
+  static fromStringLiteral(initial: string = ""): Sink {
+    const sink = new Sink();
+    const size = (<u32>initial.length) << 1;
+    sink.buffer = changetype<ArrayBuffer>(__new(size, idof<ArrayBuffer>()));
+    if (size) {
+      memory.copy(
+        changetype<usize>(sink.buffer),
+        changetype<usize>(initial),
+        size,
+      );
+      sink.offset += size;
     }
-
-    writeCodePoint16(code: i32): Sink {
-        this.ensureCapacity(2);
-
-        let offset = this.offset;
-        let dest = changetype<usize>(this.buffer) + offset;
-
-        store<u16>(dest, <u16>code);
-        this.offset = offset + 2;
-
-        return this;
+    return sink;
+  }
+
+  static fromBuffer(
+    initial: ArrayBuffer,
+    capacity: i32 = MIN_BUFFER_LEN,
+  ): Sink {
+    const sink = new Sink();
+    const size = <u32>initial.byteLength;
+    sink.buffer = changetype<ArrayBuffer>(
+      __new(
+        max<u32>(size, max<u32>(MIN_BUFFER_SIZE, (<u32>capacity) << 1)),
+        idof<ArrayBuffer>(),
+      ),
+    );
+    if (size) {
+      memory.copy(
+        changetype<usize>(sink.buffer),
+        changetype<usize>(initial),
+        size,
+      );
+      sink.offset = size;
     }
-
-    writeCodePointUnsafe(code: i32): Sink {
-        this.ensureCapacity(2);
-
-        let offset = this.offset;
-        let dest = changetype<usize>(this.buffer) + offset;
-
-        code -= 0x10000;
-        let hi = (code & 0x03FF) | 0xDC00;
-        let lo = code >>> 10 | 0xD800;
-        store<u32>(dest, lo | hi << 16);
-        this.offset = offset + 4;
-        return this;
+    return sink;
+  }
+
+  constructor() {}
+
+  get length(): i32 {
+    return this.offset >> 1;
+  }
+
+  get capacity(): i32 {
+    return this.buffer.byteLength >>> 1;
+  }
+  reset(): void {
+    this.offset = 0;
+  }
+  write(src: string, start: i32 = 0, end: i32 = i32.MAX_VALUE): Sink | null {
+    let len = src.length as u32;
+
+    if (start != 0 || end != i32.MAX_VALUE) {
+      let from: i32;
+      from = min<i32>(max(start, 0), len);
+      end = min<i32>(max(end, 0), len);
+      start = min<i32>(from, end);
+      end = max<i32>(from, end);
+      len = end - start;
     }
 
-    writeNumber<T extends number>(value: T): Sink {
-        let offset = this.offset;
-        if (isInteger<T>()) {
-            let maxCapacity = 0;
-            // this also include size for sign
-            if (sizeof<T>() == 1) {
-                maxCapacity = 4 << 1;
-            } else if (sizeof<T>() == 2) {
-                maxCapacity = 6 << 1;
-            } else if (sizeof<T>() == 4) {
-                maxCapacity = 11 << 1;
-            } else if (sizeof<T>() == 8) {
-                maxCapacity = 21 << 1;
-            }
-            this.ensureCapacity(maxCapacity);
-            offset += itoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        } else {
-            this.ensureCapacity(32 << 1);
-            offset += dtoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        }
-        this.offset = offset;
-        return this;
-    }
-    writeNumberUnsafe<T extends number>(value: T): Sink {
-        let offset = this.offset;
-        if (isInteger<T>()) {
-            offset += itoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        } else {
-            offset += dtoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        }
-        this.offset = offset;
-        return this;
-    }
-    writeIntegerUnsafe<T extends number>(value: T): Sink {
-        let offset = this.offset;
-        if (isInteger<T>()) {
-            offset += itoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        } else {
-            offset += dtoa_buffered(
-                changetype<usize>(this.buffer) + offset,
-                value
-            ) << 1;
-        }
-        this.offset = offset;
-        return this;
+    if (!len) return null;
+
+    let size = len << 1;
+    this.ensureCapacity(size);
+    let offset = this.offset;
+
+    memory.copy(
+      changetype<usize>(this.buffer) + offset,
+      changetype<usize>(src) + ((<usize>start) << 1),
+      size,
+    );
+    this.offset = offset + size;
+    return this;
+  }
+
+  writeLn(src: string = "", start: i32 = 0, end: i32 = i32.MAX_VALUE): Sink {
+    let len = src.length as u32;
+    if (start != 0 || end != i32.MAX_VALUE) {
+      let from: i32;
+      from = min<i32>(max(start, 0), len);
+      end = min<i32>(max(end, 0), len);
+      start = min<i32>(from, end);
+      end = max<i32>(from, end);
+      len = end - start;
     }
 
-    reserve(capacity: i32, clear: bool = false): void {
-        if (clear) this.offset = 0;
-        this.buffer = changetype<ArrayBuffer>(__renew(
-            changetype<usize>(this.buffer),
-            max<u32>(this.offset, max<u32>(MIN_BUFFER_SIZE, <u32>capacity << 1))
-        ));
+    let size = len << 1;
+    this.ensureCapacity(size + 2);
+    let offset = this.offset;
+    let dest = changetype<usize>(this.buffer) + offset;
+    if (size)
+      memory.copy(dest, changetype<usize>(src) + ((<usize>start) << 1), size);
+    store<u16>(dest + size, NEW_LINE_CHAR);
+    this.offset = offset + (size + 2);
+    return this;
+  }
+
+  writeCodePoint(code: i32): Sink {
+    let hasSur = <u32>code > 0xffff;
+    this.ensureCapacity(2 << i32(hasSur));
+
+    let offset = this.offset;
+    let dest = changetype<usize>(this.buffer) + offset;
+
+    if (!hasSur) {
+      store<u16>(dest, <u16>code);
+      this.offset = offset + 2;
+    } else {
+      assert(<u32>code <= 0x10ffff);
+      code -= 0x10000;
+      let hi = (code & 0x03ff) | 0xdc00;
+      let lo = (code >>> 10) | 0xd800;
+      store<u32>(dest, lo | (hi << 16));
+      this.offset = offset + 4;
     }
-
-    shrink(): void {
-        this.buffer = changetype<ArrayBuffer>(__renew(
-            changetype<usize>(this.buffer),
-            max<u32>(this.offset, MIN_BUFFER_SIZE)
-        ));
+    return this;
+  }
+
+  writeCodePoint16(code: i32): Sink {
+    this.ensureCapacity(2);
+
+    let offset = this.offset;
+    let dest = changetype<usize>(this.buffer) + offset;
+
+    store<u16>(dest, <u16>code);
+    this.offset = offset + 2;
+
+    return this;
+  }
+
+  writeCodePointUnsafe(code: i32): Sink {
+    this.ensureCapacity(2);
+
+    let offset = this.offset;
+    let dest = changetype<usize>(this.buffer) + offset;
+
+    code -= 0x10000;
+    let hi = (code & 0x03ff) | 0xdc00;
+    let lo = (code >>> 10) | 0xd800;
+    store<u32>(dest, lo | (hi << 16));
+    this.offset = offset + 4;
+    return this;
+  }
+
+  writeNumber<T extends number>(value: T): Sink {
+    let offset = this.offset;
+    if (isInteger<T>()) {
+      let maxCapacity = 0;
+      // this also include size for sign
+      if (sizeof<T>() == 1) {
+        maxCapacity = 4 << 1;
+      } else if (sizeof<T>() == 2) {
+        maxCapacity = 6 << 1;
+      } else if (sizeof<T>() == 4) {
+        maxCapacity = 11 << 1;
+      } else if (sizeof<T>() == 8) {
+        maxCapacity = 21 << 1;
+      }
+      this.ensureCapacity(maxCapacity);
+      offset +=
+        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+    } else {
+      this.ensureCapacity(32 << 1);
+      offset +=
+        dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
-
-    clear(): void {
-        this.reserve(0, true);
+    this.offset = offset;
+    return this;
+  }
+  writeNumberUnsafe<T extends number>(value: T): Sink {
+    let offset = this.offset;
+    if (isInteger<T>()) {
+      offset +=
+        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+    } else {
+      offset +=
+        dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
-
-    toString(): string {
-        let size = this.offset;
-        if (!size) return "";
-        let out = changetype<string>(__new(size, idof<string>()));
-        memory.copy(changetype<usize>(out), changetype<usize>(this.buffer), size);
-        return out;
+    this.offset = offset;
+    return this;
+  }
+  writeIntegerUnsafe<T extends number>(value: T): Sink {
+    let offset = this.offset;
+    if (isInteger<T>()) {
+      offset +=
+        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+    } else {
+      offset +=
+        dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
-
-    ensureCapacity(deltaBytes: u32): void {
-        let buffer = this.buffer;
-        let newSize = this.offset + deltaBytes;
-        if (newSize > <u32>buffer.byteLength) {
-            this.buffer = changetype<ArrayBuffer>(__renew(
-                changetype<usize>(buffer),
-                nextPowerOf2(newSize)
-            ));
-        }
+    this.offset = offset;
+    return this;
+  }
+
+  reserve(capacity: i32, clear: bool = false): void {
+    if (clear) this.offset = 0;
+    this.buffer = changetype<ArrayBuffer>(
+      __renew(
+        changetype<usize>(this.buffer),
+        max<u32>(this.offset, max<u32>(MIN_BUFFER_SIZE, (<u32>capacity) << 1)),
+      ),
+    );
+  }
+
+  shrink(): void {
+    this.buffer = changetype<ArrayBuffer>(
+      __renew(
+        changetype<usize>(this.buffer),
+        max<u32>(this.offset, MIN_BUFFER_SIZE),
+      ),
+    );
+  }
+
+  clear(): void {
+    this.reserve(0, true);
+  }
+
+  toString(): string {
+    let size = this.offset;
+    if (!size) return "";
+    let out = changetype<string>(__new(size, idof<string>()));
+    memory.copy(changetype<usize>(out), changetype<usize>(this.buffer), size);
+    return out;
+  }
+
+  ensureCapacity(deltaBytes: u32): void {
+    let buffer = this.buffer;
+    let newSize = this.offset + deltaBytes;
+    if (newSize > <u32>buffer.byteLength) {
+      this.buffer = changetype<ArrayBuffer>(
+        __renew(changetype<usize>(buffer), nextPowerOf2(newSize)),
+      );
     }
-}
+  }
+}

package/assembly/custom/types.ts

@@ -1,4 +1,4 @@
 @json
 export class Vec3 {
   x: f64 = 1.0;
-}
+}

package/assembly/deserialize/array.ts

@@ -9,30 +9,34 @@ import { deserializeStringArray } from "./array/string";
 
 // @ts-ignore: Decorator valid here
 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>() + "! Make sure to add the @json decorator over classes!");
-    } else {
-        throw new Error("Could not parse array of type " + nameof<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>() +
+        "! Make sure to add the @json decorator over classes!",
+    );
+  } else {
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  }
+}

package/assembly/index.d.ts

@@ -18,7 +18,6 @@ declare function alias(name: string): Function;
  */
 declare function omit(): Function;
 
-
 /**
  * Property decorator that allows a field to be omitted when equal to an Expression.
  */
@@ -33,4 +32,4 @@ declare function omitnull(): Function;
  * Property decorator that allows a field to be flattened.
  * @param fieldName - Points to the field to flatten. Can use dot-notation here like @omit("foo.identifier.text")
  */
-declare function flatten(fieldName: string = "value"): Function;
+declare function flatten(fieldName: string = "value"): Function;