json-as 0.9.28 → 0.9.29

package/.prettierrc.json

@@ -1,4 +1,6 @@
 {
   "singleQuote": false,
-  "printWidth": 65536
+  "printWidth": 65536,
+  "pluginSearchDirs": ["node_modules"],
+  "plugins": ["assemblyscript-prettier"]
 }

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v0.9.28
+    AssemblyScript - v0.9.29
   </pre>
 </h5>
 

package/assembly/__benches__/misc.bench.ts

@@ -2,32 +2,33 @@ import { JSON } from "..";
 import { BRACE_LEFT, BRACKET_LEFT, CHAR_F, CHAR_T, QUOTE } from "../custom/chars";
 
 bench("Match Type (string)", () => {
-    blackbox<boolean>(matchType(blackbox<string>("\""), JSON.Types.String));
+  blackbox<boolean>(matchType(blackbox<string>('"'), JSON.Types.String));
 });
 
 bench("Match Type (bool)", () => {
-    blackbox<boolean>(matchType(blackbox<string>("t"), JSON.Types.Bool));
+  blackbox<boolean>(matchType(blackbox<string>("t"), JSON.Types.Bool));
 });
 
 bench("Match Type (array)", () => {
-    blackbox<boolean>(matchType(blackbox<string>("["), JSON.Types.Array));
+  blackbox<boolean>(matchType(blackbox<string>("["), JSON.Types.Array));
 });
 
 bench("Match Type (struct)", () => {
-    blackbox<boolean>(matchType(blackbox<string>("{"), JSON.Types.Obj));
+  blackbox<boolean>(matchType(blackbox<string>("{"), JSON.Types.Obj));
 });
 
 bench("Match Type (raw)", () => {
-    blackbox<boolean>(matchType(blackbox<string>("\""), JSON.Types.Raw));
+  blackbox<boolean>(matchType(blackbox<string>('"'), JSON.Types.Raw));
 });
 
+
 @inline function matchType(data: string, type: JSON.Types): boolean {
-    const firstChar = load<u8>(changetype<usize>(data));
-    if (JSON.Types.String == type && firstChar == QUOTE) return true;
-    else if (JSON.Types.Bool == type && (firstChar == CHAR_T || firstChar == CHAR_F)) return true;
-    else if (JSON.Types.Array == type && firstChar == BRACKET_LEFT) return true;
-    else if (JSON.Types.Obj == type && firstChar == BRACE_LEFT) return true;
-    else if (type < 7 && type > 0 && (firstChar < 58 && firstChar > 46)) return true;
-    else if (JSON.Types.Raw == type) return true;
-    else return false;
-}
+  const firstChar = load<u8>(changetype<usize>(data));
+  if (JSON.Types.String == type && firstChar == QUOTE) return true;
+  else if (JSON.Types.Bool == type && (firstChar == CHAR_T || firstChar == CHAR_F)) return true;
+  else if (JSON.Types.Array == type && firstChar == BRACKET_LEFT) return true;
+  else if (JSON.Types.Obj == type && firstChar == BRACE_LEFT) return true;
+  else if (type < 7 && type > 0 && firstChar < 58 && firstChar > 46) return true;
+  else if (JSON.Types.Raw == type) return true;
+  else return false;
+}

package/assembly/__tests__/date.spec.ts

@@ -0,0 +1,12 @@
+import { JSON } from "json-as";
+import { describe, expect, run } from "as-test/assembly";
+
+describe("Should serialize dates", () => {
+  expect(JSON.stringify(new Date(1767184496789))).toBe('"2025-12-31T12:34:56.789Z"');
+});
+
+describe("Should deserialize dates", () => {
+  expect(JSON.parse<Date>('"2025-12-31T12:34:56.789Z"').getTime()).toBe(1767184496789);
+});
+
+run();

package/assembly/__tests__/types.ts

@@ -1,28 +1,36 @@
+
 @json
 export class ObjWithString {
   s!: string;
 }
 
+
 @json
 export class ObjWithStrangeKey<T> {
+
   @alias('a\\\t"\x02b`c')
   data!: T;
 }
+
+
 @json
 export class ObjectWithStringArray {
   sa!: string[];
 }
 
+
 @json
 export class ObjectWithFloat {
   f!: f64;
 }
 
+
 @json
 export class ObjectWithFloatArray {
   fa!: f64[];
 }
 
+
 @json
 export class BaseObject {
   a: string;
@@ -31,6 +39,7 @@ export class BaseObject {
   }
 }
 
+
 @json
 export class DerivedObject extends BaseObject {
   b: string;
@@ -40,6 +49,7 @@ export class DerivedObject extends BaseObject {
   }
 }
 
+
 @json
 export class Map4 {
   a: string;
@@ -48,6 +58,7 @@ export class Map4 {
   d: string;
 }
 
+
 @json
 export class Vec3 {
   x: f64;
@@ -57,6 +68,7 @@ export class Vec3 {
   static shouldIgnore: string = "should not be serialized";
 }
 
+
 @json
 export class Player {
   firstName: string;
@@ -70,12 +82,17 @@ export class Player {
 export class Nullable {}
 export type Null = Nullable | null;
 
+
 @json
 export class OmitIf {
   x: i32 = 1;
+
+
   @omitif("this.y == -1")
   y: i32 = -1;
   z: i32 = 1;
+
+
   @omitnull()
   foo: string | null = null;
 }

package/assembly/custom/bs.ts

@@ -11,201 +11,192 @@ let POINTER = changetype<usize>(CACHE);
 @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();
-    }
-
-    // @ts-ignore
-    @inline export function shrink(): void {
-        const len = POINTER - CACHE;
-        STORE_LEN += len;
-        const out = __new(
-            len,
-            idof<ArrayBuffer>()
-        );
-        memory.copy(out, CACHE, len);
-        bs.reset();
-        STORE.push(out);
-    }
-
-    // @ts-ignore
-    @inline export function out<T>(): T {
-        const len = POINTER - CACHE;
-        let out = __new(
-            len + STORE_LEN,
-            idof<T>()
-        );
-
-        memory.copy(out, CACHE, len);
-        if (STORE_LEN) {
-            out += len;
-            for (let i = 0; i < STORE.length; i++) {
-                const ptr = changetype<usize>(unchecked(STORE[i]));
-                const storeLen = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtSize;
-                memory.copy(out, ptr, storeLen);
-                //__unpin(ptr);
-                out += storeLen;
-            }
-            STORE_LEN = 0;
-        }
-        bs.reset();
-
-        return changetype<T>(out);
-    }
-
-    // @ts-ignore
-    @inline export function out_u<T>(): T {
-        const len = POINTER - CACHE;
-        const out = __new(
-            len + STORE_LEN,
-            idof<T>()
-        );
-
-        memory.copy(out, CACHE, len);
-        bs.reset();
-
-        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;
-    }
-}
+  // @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();
+  }
+
+  // @ts-ignore
+  @inline export function shrink(): void {
+    const len = POINTER - CACHE;
+    STORE_LEN += len;
+    const out = __new(len, idof<ArrayBuffer>());
+    memory.copy(out, CACHE, len);
+    bs.reset();
+    STORE.push(out);
+  }
+
+  // @ts-ignore
+  @inline export function out<T>(): T {
+    const len = POINTER - CACHE;
+    let out = __new(len + STORE_LEN, idof<T>());
+
+    memory.copy(out, CACHE, len);
+    if (STORE_LEN) {
+      out += len;
+      for (let i = 0; i < STORE.length; i++) {
+        const ptr = changetype<usize>(unchecked(STORE[i]));
+        const storeLen = changetype<OBJECT>(ptr - TOTAL_OVERHEAD).rtSize;
+        memory.copy(out, ptr, storeLen);
+        //__unpin(ptr);
+        out += storeLen;
+      }
+      STORE_LEN = 0;
+    }
+    bs.reset();
+
+    return changetype<T>(out);
+  }
+
+  // @ts-ignore
+  @inline export function out_u<T>(): T {
+    const len = POINTER - CACHE;
+    const out = __new(len + STORE_LEN, idof<T>());
+
+    memory.copy(out, CACHE, len);
+    bs.reset();
+
+    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/chars.ts

@@ -59,9 +59,9 @@
 // @ts-ignore: Decorator is valid here
 @inline export const BRACKET_RIGHT_WORD = "]";
 // @ts-ignore: Decorator is valid here
-@inline export const QUOTE_WORD = "\"";
+@inline export const QUOTE_WORD = '"';
 // @ts-ignore: Decorator is valid here
-@inline export const EMPTY_QUOTE_WORD = "\"\"";
+@inline export const EMPTY_QUOTE_WORD = '""';
 
 // Escape Codes
 // @ts-ignore: Decorator is valid here

package/assembly/custom/types.ts

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