json-as 0.9.20 → 0.9.22

package/assembly/custom/bs.ts

@@ -1,103 +1,153 @@
 import { dtoa_buffered, itoa_buffered } from "util/number";
 import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+// @ts-ignore
 @inline const MAX_LEN: usize = 65536;
 const STORE: usize[] = [];
 let STORE_LEN: usize = 0;
 const CACHE = memory.data(i32(MAX_LEN));
 // Configurable amount of referenceable strings
 let POINTER = changetype<usize>(CACHE);
+// @ts-ignore
 @inline const MAX_CACHE = CACHE + MAX_LEN;
 
 export namespace bs {
+    // @ts-ignore
     @inline export function write_int<T extends number>(num: T): void {
         POINTER += itoa_buffered(POINTER, num) << 1;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_int_u<T extends number>(num: T): void {
         POINTER += itoa_buffered(POINTER, num) << 1;
     }
 
+    // @ts-ignore
     @inline export function write_fl<T extends number>(num: T): void {
         POINTER += dtoa_buffered(POINTER, num) << 1;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_fl_u<T extends number>(num: T): void {
         POINTER += dtoa_buffered(POINTER, num) << 1;
     }
 
+    // @ts-ignore
     @inline export function write_b(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
         memory.copy(POINTER, buf, bytes);
         POINTER += bytes;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_b_u(buf: usize, bytes: usize = changetype<OBJECT>(buf - TOTAL_OVERHEAD).rtSize): void {
         memory.copy(POINTER, buf, bytes);
         POINTER += bytes;
     }
 
+    // @ts-ignore
     @inline export function write_s(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
         memory.copy(POINTER, changetype<usize>(str), bytes);
         POINTER += bytes;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_s_u(str: string, bytes: usize = changetype<OBJECT>(changetype<usize>(str) - TOTAL_OVERHEAD).rtSize): void {
         memory.copy(POINTER, changetype<usize>(str), bytes);
         POINTER += bytes;
     }
 
+    // @ts-ignore
     @inline export function write_s_se(str: string, start: usize, end: usize): void {
         const bytes = end - start;
         memory.copy(POINTER, changetype<usize>(str) + start, bytes);
         POINTER += bytes;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_s_se_u(str: string, start: usize, end: usize): void {
         const bytes = end - start;
         memory.copy(POINTER, changetype<usize>(str) + start, bytes);
         POINTER += bytes;
     }
 
+    // @ts-ignore
+    @inline export function write_8(char: i32): void {
+        store<u8>(POINTER, char);
+        POINTER += 2;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+
+    // @ts-ignore
+    @inline export function write_8_u(char: i32): void {
+        store<u8>(POINTER, char);
+        //POINTER += 2;
+    }
+
+    // @ts-ignore
     @inline export function write_16(char: i32): void {
         store<u16>(POINTER, char);
         POINTER += 2;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_16_u(char: i32): void {
         store<u16>(POINTER, char);
         //POINTER += 2;
     }
 
+    // @ts-ignore
     @inline export function write_32(chars: i32): void {
         store<u32>(POINTER, chars);
         POINTER += 4;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function write_32_u(chars: i32): void {
         store<u32>(POINTER, chars);
         //POINTER += 4;
     }
 
+    // @ts-ignore
     @inline export function write_64(chars: i64): void {
         store<u64>(POINTER, chars);
         POINTER += 8;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
 
+    // @ts-ignore
     @inline export function write_64_u(chars: i64): void {
         store<u64>(POINTER, chars);
         POINTER += 8;
     }
 
+    // @ts-ignore
     @inline export function write_128(chars: v128): void {
         store<v128>(POINTER, chars);
         POINTER += 16;
         if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
+    @inline export function write_128_n(chars: v128, n: usize): void {
+        store<v128>(POINTER, chars);
+        POINTER += n;
+        if (MAX_CACHE <= POINTER) bs.shrink();
+    }
+
+    // @ts-ignore
     @inline export function write_128_u(chars: v128): void {
         store<v128>(POINTER, chars);
         //POINTER += 16;
-       //if (MAX_CACHE <= POINTER) bs.shrink();
+        //if (MAX_CACHE <= POINTER) bs.shrink();
     }
+
+    // @ts-ignore
     @inline export function shrink(): void {
         const len = POINTER - CACHE;
         STORE_LEN += len;
@@ -109,6 +159,8 @@ export namespace bs {
         bs.reset();
         STORE.push(out);
     }
+
+    // @ts-ignore
     @inline export function out<T>(): T {
         const len = POINTER - CACHE;
         let out = __new(
@@ -133,6 +185,7 @@ export namespace bs {
         return changetype<T>(out);
     }
 
+    // @ts-ignore
     @inline export function out_u<T>(): T {
         const len = POINTER - CACHE;
         const out = __new(
@@ -146,9 +199,12 @@ export namespace bs {
         return changetype<T>(out);
     }
 
+    // @ts-ignore
     @inline export function _out(out: usize): void {
         memory.copy(out, CACHE, POINTER - CACHE);
     }
+
+    // @ts-ignore
     @inline export function reset(): void {
         POINTER = CACHE;
     }

package/assembly/custom/sink.ts

@@ -16,33 +16,16 @@ export class Sink {
 
   static withCapacity(capacity: i32): Sink {
     const sink = new Sink();
-    sink.buffer = changetype<ArrayBuffer>(
-      __new(
-        max<u32>(MIN_BUFFER_SIZE, (<u32>capacity) << 1),
-        idof<ArrayBuffer>(),
-      ),
-    );
+    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 {
+  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>(),
-      ),
-    );
+    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,
-      );
+      memory.copy(changetype<usize>(sink.buffer), changetype<usize>(initial), size);
       sink.offset += size;
     }
     return sink;
@@ -53,34 +36,18 @@ export class 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,
-      );
+      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 {
+  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>(),
-      ),
-    );
+    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,
-      );
+      memory.copy(changetype<usize>(sink.buffer), changetype<usize>(initial), size);
       sink.offset = size;
     }
     return sink;
@@ -116,11 +83,7 @@ export class Sink {
     this.ensureCapacity(size);
     let offset = this.offset;
 
-    memory.copy(
-      changetype<usize>(this.buffer) + offset,
-      changetype<usize>(src) + ((<usize>start) << 1),
-      size,
-    );
+    memory.copy(changetype<usize>(this.buffer) + offset, changetype<usize>(src) + ((<usize>start) << 1), size);
     this.offset = offset + size;
     return this;
   }
@@ -140,8 +103,7 @@ export class Sink {
     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);
+    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;
@@ -209,12 +171,10 @@ export class Sink {
         maxCapacity = 21 << 1;
       }
       this.ensureCapacity(maxCapacity);
-      offset +=
-        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+      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;
+      offset += dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
     this.offset = offset;
     return this;
@@ -222,11 +182,9 @@ export class Sink {
   writeNumberUnsafe<T extends number>(value: T): Sink {
     let offset = this.offset;
     if (isInteger<T>()) {
-      offset +=
-        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+      offset += itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     } else {
-      offset +=
-        dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+      offset += dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
     this.offset = offset;
     return this;
@@ -234,11 +192,9 @@ export class Sink {
   writeIntegerUnsafe<T extends number>(value: T): Sink {
     let offset = this.offset;
     if (isInteger<T>()) {
-      offset +=
-        itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+      offset += itoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     } else {
-      offset +=
-        dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
+      offset += dtoa_buffered(changetype<usize>(this.buffer) + offset, value) << 1;
     }
     this.offset = offset;
     return this;
@@ -246,21 +202,11 @@ export class Sink {
 
   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)),
-      ),
-    );
+    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),
-      ),
-    );
+    this.buffer = changetype<ArrayBuffer>(__renew(changetype<usize>(this.buffer), max<u32>(this.offset, MIN_BUFFER_SIZE)));
   }
 
   clear(): void {
@@ -279,9 +225,7 @@ export class Sink {
     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.buffer = changetype<ArrayBuffer>(__renew(changetype<usize>(buffer), nextPowerOf2(newSize)));
     }
   }
 }

package/assembly/deserialize/array.ts

@@ -31,11 +31,7 @@ export function deserializeArray<T extends unknown[]>(data: string): T {
     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!",
-    );
+    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/deserialize/string.ts

@@ -1,3 +1,4 @@
+import { bs } from "../custom/bs";
 import {
     CHAR_B,
     BACK_SLASH,
@@ -85,4 +86,73 @@ import { unsafeCharCodeAt } from "../custom/util";
         result.write(data, last, end);
     }
     return result.toString()
-}
+}
+
+// @ts-ignore: Decorator valid here
+// @inline export function deserializeString_BS(data: string, start: i32 = 0, end: i32 = 0): void {
+//     end = end || data.length - 1;
+//     let last = start + 1;
+//     for (let i = last; i < end; i++) {
+//         if (unsafeCharCodeAt(data, i) !== BACK_SLASH) {
+//             continue;
+//         }
+//         const char = unsafeCharCodeAt(data, ++i);
+//         bs.write_s_se_u(data, last, i - 1);
+//         switch (char) {
+//             case QUOTE: {
+//                 bs.write_8(QUOTE);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case BACK_SLASH: {
+//                 bs.write_8(BACK_SLASH);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case FWD_SLASH: {
+//                 bs.write_8(FWD_SLASH);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_B: {
+//                 bs.write_8(BACKSPACE);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_F: {
+//                 bs.write_8(FORM_FEED);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_N: {
+//                 bs.write_8(NEW_LINE);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_R: {
+//                 bs.write_8(CARRIAGE_RETURN);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_T: {
+//                 bs.write_8(TAB);
+//                 last = i + 1;
+//                 break;
+//             }
+//             case CHAR_U: {
+                
+//                 const code = u16.parse(data.slice(i + 1, i + 5), 16);
+//                 bs.w(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);
+//     }
+// }

package/assembly/index.ts

@@ -3,7 +3,7 @@ import { serializeString } from "./serialize/string";
 import { serializeBool } from "./serialize/bool";
 import { serializeInteger } from "./serialize/integer";
 import { serializeFloat } from "./serialize/float";
-import { serializeObject } from "./serialize/object";
+import { serializeObject, serializeObject_Pretty } from "./serialize/object";
 import { serializeDate } from "./serialize/date";
 import { serializeArray } from "./serialize/array";
 import { serializeMap } from "./serialize/map";
@@ -13,11 +13,18 @@ import { deserializeFloat } from "./deserialize/float";
 import { deserializeObject } from "./deserialize/object";
 import { deserializeMap } from "./deserialize/map";
 import { deserializeDate } from "./deserialize/date";
-import { BRACKET_LEFT, NULL_WORD } from "./custom/chars";
+import { NULL_WORD } from "./custom/chars";
 import { deserializeInteger } from "./deserialize/integer";
 import { deserializeString } from "./deserialize/string";
 import { Sink } from "./custom/sink";
-import { bs } from "./custom/bs";
+import { getArrayDepth } from "./custom/util";
+
+// Config
+class SerializeOptions {
+  public pretty: bool = false;
+}
+
+const DEFAULT_SERIALIZE_OPTIONS = new SerializeOptions();
 
 /**
  * Offset of the 'storage' property in the JSON.Value class.
@@ -167,7 +174,7 @@ export namespace JSON {
    * @returns string
    */
   // @ts-ignore: Decorator
-  export function stringify<T>(data: T): string {
+  export function stringify<T>(data: T/*, options: SerializeOptions = DEFAULT_SERIALIZE_OPTIONS*/): string {
     if (isBoolean<T>()) {
       return serializeBool(data as bool);
     } else if (isInteger<T>()) {
@@ -184,6 +191,10 @@ export namespace JSON {
       return serializeString(changetype<string>(data));
       // @ts-ignore: Supplied by transform
     } else if (isDefined(data.__SERIALIZE)) {
+      /*if (options.pretty) {
+        // @ts-ignore
+        return serializeObject_Pretty(changetype<nonnull<T>>(data));
+      }*/
       // @ts-ignore
       return serializeObject(changetype<nonnull<T>>(data));
     } else if (data instanceof Date) {
@@ -229,7 +240,7 @@ export namespace JSON {
       return deserializeArray<nonnull<T>>(data);
     }
     let type: nonnull<T> = changetype<nonnull<T>>(0);
-    // @ts-ignore: Defined by trasnform
+    // @ts-ignore: Defined by transform
     if (isDefined(type.__DESERIALIZE)) {
       // @ts-ignore
       return deserializeObject<nonnull<T>>(data.trimStart());

package/assembly/serialize/bool.ts

@@ -3,7 +3,20 @@
  * @param data data to serialize
  * @returns string
  */
+
+import { bs } from "../custom/bs";
+
 // @ts-ignore: Decorator valid here
 @inline export function serializeBool(data: bool): string {
     return data ? "true" : "false";
+}
+
+@inline export function serializeBool_BS(data: bool): void {
+    if (data === true) {
+        bs.write_64(28429475166421108); /* true */
+    } else {
+        //bs.write_128_n(i16x8(102, 97, 108, 115, 101, 0, 0, 0), 10);
+        bs.write_64(32370086184550502); /* fals */
+        bs.write_16(101); /* e */
+    }
 }

package/assembly/serialize/object.ts

@@ -5,4 +5,9 @@ interface GeneratedInterface {
 // @ts-ignore: Decorator valid here
 @inline export function serializeObject<T extends GeneratedInterface>(data: T): string {
     return changetype<nonnull<T>>(data).__SERIALIZE();
+}
+
+// @ts-ignore: Decorator valid here
+@inline export function serializeObject_Pretty<T extends GeneratedInterface>(data: T): string {
+    return changetype<nonnull<T>>(data).__SERIALIZE_PRETTY();
 }