json-as 0.8.6 → 0.8.8

package/assembly/src/sink.ts

@@ -0,0 +1,286 @@
+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
+
+// @ts-ignore: decorator
+@inline function nextPowerOf2(n: u32): u32 {
+    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;
+    }
+
+    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() { }
+
+    @inline get length(): i32 {
+        return this.offset >> 1;
+    }
+
+    @inline get capacity(): i32 {
+        return this.buffer.byteLength >>> 1;
+    }
+    @inline reset(): void {
+        this.offset = 0;
+    }
+    @inline 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;
+    }
+
+    @inline 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;
+    }
+
+    @inline 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;
+    }
+
+    @inline 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;
+    }
+
+    @inline 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;
+    }
+
+    @inline 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;
+    }
+    @inline 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;
+    }
+    @inline 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;
+    }
+
+    @inline 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))
+        ));
+    }
+
+    @inline shrink(): void {
+        this.buffer = changetype<ArrayBuffer>(__renew(
+            changetype<usize>(this.buffer),
+            max<u32>(this.offset, MIN_BUFFER_SIZE)
+        ));
+    }
+
+    @inline clear(): void {
+        this.reserve(0, true);
+    }
+
+    @inline 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;
+    }
+
+    @inline 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/src/util.ts

@@ -2,6 +2,12 @@ import { StringSink } from "as-string-sink/assembly";
 import { isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
+// @ts-ignore: Decorator
+@inline export function isMap<T>(): bool {
+  let type = changetype<T>(0);
+  return type instanceof Map;
+}
+
 // @ts-ignore: Decorator
 @inline export function unsafeCharCodeAt(data: string, pos: i32): i32 {
   return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));

package/assembly/test.ts

@@ -9,11 +9,18 @@ class Foo {
   tristateValue: Box<bool> | null = null;
 }
 
+@json
+class TestBody {
+  a!: string;
+  b!: u8;
+}
+
 const foo: Foo = {
   optionalNumber: null,
   tristateValue: Box.from(true)
 }
-
+console.log(JSON.stringify(JSON.parse<TestBody[]>('[{"a":"hi","b":5},{"a":"bye","b":6}]')))
+console.log(JSON.stringify([foo, foo]))
 console.log(JSON.stringify(foo));
 
 const p1 = JSON.parse<Box<i32> | null>("null");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",

package/transform/lib/index.js

@@ -39,7 +39,7 @@ class AsJSONTransform extends BaseVisitor {
             return;
         // Prevent from being triggered twice.
         for (const member of node.members) {
-            if (member.name.text == "__JSON_Serialize")
+            if (member.name.text == "__SERIALIZE")
                 return;
         }
         this.currentClass = {
@@ -151,13 +151,13 @@ class AsJSONTransform extends BaseVisitor {
             this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
                 stmt.slice(0, stmt.length - 1);
             serializeFunc = `
-      __JSON_Serialize(): string {
+      __SERIALIZE(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }`;
         }
         else {
             serializeFunc = `
-      __JSON_Serialize(): string {
+      __SERIALIZE(): string {
         return "{}";
       }`;
         }

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "JSON encoder/decoder for AssemblyScript",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -46,7 +46,7 @@ class AsJSONTransform extends BaseVisitor {
 
     // Prevent from being triggered twice.
     for (const member of node.members) {
-      if (member.name.text == "__JSON_Serialize") return;
+      if (member.name.text == "__SERIALIZE") return;
     }
 
     this.currentClass = {
@@ -194,12 +194,12 @@ class AsJSONTransform extends BaseVisitor {
       this.currentClass.encodeStmts[this.currentClass.encodeStmts.length - 1] =
         stmt!.slice(0, stmt.length - 1);
       serializeFunc = `
-      __JSON_Serialize(): string {
+      __SERIALIZE(): string {
         return \`{${this.currentClass.encodeStmts.join("")}}\`;
       }`;
     } else {
       serializeFunc = `
-      __JSON_Serialize(): string {
+      __SERIALIZE(): string {
         return "{}";
       }`;
     }