json-as 0.8.6 → 0.8.7

package/assembly/serialize/string.ts

@@ -0,0 +1,64 @@
+import { backSlashCode, backspaceCode as BACKSPACE, carriageReturnCode as CARRIAGE_RETURN, formFeedCode as FORM_FEED, newLineCode as NEWLINE, quoteCode, quoteWord, tabCode as TAB } from "../src/chars";
+import { Sink } from "../src/sink";
+import { unsafeCharCodeAt } from "../src/util";
+
+// @ts-ignore: Decorator
+@inline export function serializeString(data: string): string {
+    if (data.length === 0) {
+        return quoteWord + quoteWord;
+    }
+
+    let result = Sink.fromString(quoteWord, data.length);
+
+    let last: i32 = 0;
+    for (let i = 0; i < data.length; i++) {
+        const char = unsafeCharCodeAt(<string>data, i);
+        if (char === quoteCode || char === backSlashCode) {
+            result.write(<string>data, last, i);
+            result.writeCodePoint(backSlashCode);
+            last = i;
+        } else if (char < 16) {
+            result.write(<string>data, last, i);
+            last = i + 1;
+            switch (char) {
+                case BACKSPACE: {
+                    result.write("\\b");
+                    break;
+                }
+                case TAB: {
+                    result.write("\\t");
+                    break;
+                }
+                case NEWLINE: {
+                    result.write("\\n");
+                    break;
+                }
+                case FORM_FEED: {
+                    result.write("\\f");
+                    break;
+                }
+                case CARRIAGE_RETURN: {
+                    result.write("\\r");
+                    break;
+                }
+                default: {
+                    // all chars 0-31 must be encoded as a four digit unicode escape sequence
+                    // \u0000 to \u000f handled here
+                    result.write("\\u000");
+                    result.write(char.toString(16));
+                    break;
+                }
+            }
+        } else if (char < 32) {
+            result.write(<string>data, last, i);
+            last = i + 1;
+            // all chars 0-31 must be encoded as a four digit unicode escape sequence
+            // \u0010 to \u001f handled here
+            result.write("\\u00");
+            result.write(char.toString(16));
+        }
+    }
+    result.write(<string>data, last);
+    result.writeCodePoint(quoteCode);
+    return result.toString();
+}

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

@@ -1,23 +1,41 @@
-import { Box } from "as-container";
-import { JSON } from "./src/json";
+import { JSON } from ".";
 
 @json
-class Foo {
-  @omitnull
-  optionalNumber: Box<i32> | null = null;
-  @omitif("this.tristateValue!.unwrap() == false")
-  tristateValue: Box<bool> | null = null;
+class Vec3 {
+  x: f32 = 0.0;
+  y: f32 = 0.0;
+  z: f32 = 0.0;
 }
 
-const foo: Foo = {
-  optionalNumber: null,
-  tristateValue: Box.from(true)
+@json
+class Player {
+  @alias("first name")
+  firstName!: string;
+  lastName!: string;
+  lastActive!: i32[];
+  @omitif("this.age < 18")
+  age!: i32;
+  @omitnull()
+  pos!: Vec3 | null;
+  isVerified!: boolean;
 }
 
-console.log(JSON.stringify(foo));
+const player: Player = {
+  firstName: "Emmet",
+  lastName: "West",
+  lastActive: [8, 27, 2022],
+  age: 13,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3
+  },
+  isVerified: true
+};
+
+const stringified = JSON.stringify<Player>(player);
+
+const parsed = JSON.parse<Player>(stringified);
 
-const p1 = JSON.parse<Box<i32> | null>("null");
-console.log(JSON.stringify<Box<i32> | null>(p1));
-console.log(changetype<usize>(p1).toString())
-const p2 = JSON.parse<Foo>("{\"optionalNumber\":null,\"tristateValue\":false}");
-console.log(JSON.stringify(p2));
+console.log("Stringified: " + stringified);
+console.log("Parsed: " + JSON.stringify(parsed));

package/bench/benchmark.ts

@@ -26,14 +26,14 @@ bench("Parse Number ATOI", () => {
 bench("Parse Number STDLIB", () => {
     blackbox<i32>(i32.parse("12345"));
 });
-*/
+
 bench("Stringify Object (Vec3)", () => {
     blackbox<string>(JSON.stringify(vec));
-});
+});*/
 
 bench("Parse Object (Vec3)", () => {
     blackbox<Vec3>(JSON.parse<Vec3>('{"x":0,"y":0,"z":0}'));
-});
+});/*
 
 bench("Stringify Number Array", () => {
     blackbox<string>(JSON.stringify<i32[]>([1, 2, 3]));
@@ -47,6 +47,10 @@ bench("Stringify String", () => {
     blackbox<string>(JSON.stringify(blackbox('Hello "World!')));
 });
 
+bench("Parse Number ATOI", () => {
+    blackbox<i32>(__atoi_fast<i32>("12345"));
+})
+
 bench("Parse String", () => {
     blackbox<string>(JSON.parse<string>(blackbox('"Hello "World!"')));
 });

package/bench.js

@@ -34,7 +34,18 @@ const vec = {
 let data;
 
 const bench = new Bench({ time: 1000 })
-
+    /*.add("stringify float", () => {
+        data = JSON.stringify(1.2345)
+    })
+    .add("parse float", () => {
+        data = JSON.parse("1.2345")
+    })
+    .add("stringify iny", () => {
+        data = JSON.stringify(12345)
+    })
+    .add("parse int", () => {
+        data = JSON.parse("12345")
+    })
     .add("Stringify Object (Vec3)", () => {
         data = JSON.stringify(vec);
     })
@@ -54,9 +65,9 @@ const bench = new Bench({ time: 1000 })
     .add("Stringify String", () => {
         data = JSON.stringify('Hello "World!');
     })
-
+*/
     .add("Parse String", () => {
-        data = JSON.parse('"Hello "World!"');
+        data = JSON.parse('[[],[[]],[[],[[]]]]');
     })
     .todo("unimplemented .add");
 

package/index.ts

@@ -1 +1 @@
-export { JSON } from "./assembly/src/json";
+export { JSON } from "./assembly/index";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -15,12 +15,12 @@
   ],
   "license": "MIT",
   "scripts": {
-    "test": "asp",
-    "bench:astral": "astral --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior never --runtime stub",
-    "build:test": "asc assembly/test.ts -o build/test.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always --runtime stub",
+    "test": "wasmtime build/serialize.spec.wasm && wasmtime build/deserialize.spec.wasm",
+    "tests:build": "asc assembly/__tests__/serialize.spec.ts -o build/serialize.spec.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always & asc assembly/__tests__/deserialize.spec.ts -o build/deserialize.spec.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always",
+    "build:test": "asc assembly/test.ts -o build/test.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always",
     "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub",
     "bench:wasmtime": "wasmtime ./bench/benchmark.wasm",
-    "bench:wavm": "wavm run ./bench/benchmark.wasm",
+    "bench:wazmer": "wasmer --llvm ./bench/benchmark.wasm",
     "build:transform": "tsc -p ./transform",
     "test:wasmtime": "wasmtime ./build/test.wasm",
     "test:wavm": "wavm run ./build/test.wasm",
@@ -29,14 +29,12 @@
     "prettier": "as-prettier -w ."
   },
   "devDependencies": {
-    "@as-pect/cli": "^8.1.0",
-    "@as-tral/cli": "^3.0.2",
     "@assemblyscript/wasi-shim": "^0.1.0",
     "as-bench": "^0.0.0-alpha",
+    "as-test": "JairusSW/as-test",
     "assemblyscript": "^0.27.22",
     "assemblyscript-prettier": "^3.0.1",
     "benchmark": "^2.1.4",
-    "kati": "^0.6.2",
     "microtime": "^3.1.1",
     "prettier": "^3.1.1",
     "tinybench": "^2.5.1",