json-as 0.2.6 → 0.4.0

package/assembly/DynamicObject.ts

@@ -1,29 +0,0 @@
-import { unknown } from "./unknown"
-
-/**
- * Provides functionality common to all JavaScript objects.
- */
-export class DynamicObject {
-    [key: string]: any
-    // Having it marked as 'any' is for intellisense only
-    protected __data: Map<string, unknown> = new Map<string, unknown>()
-    set(path: string, value: unknown): void {
-        this.__data.set(path, value)
-    }
-    get<T = unknown>(path: string): T {
-        let type!: T
-        if (type instanceof unknown) {
-            // @ts-ignore
-            return this.__data.get(path)
-        } else {
-            // @ts-ignore
-            return this.__data.get(path).get<T>()
-        }
-    }
-    static keys(o: DynamicObject): string[] {
-        return o.__data.keys()
-    }
-    static values(o: DynamicObject): unknown[] {
-        return o.__data.values()
-    }
-}

package/assembly/bench.ts

@@ -1,199 +0,0 @@
-import 'wasi'
-
-import { Date } from 'as-wasi'
-
-import { JSON } from '.'
-
-import * as asJSON from "assemblyscript-json"
-
-import { unknown } from './unknown'
-import { DynamicObject } from './DynamicObject'
-
-// @ts-ignore
-@json
-class JSONSchema {
-    hello: string
-}
-
-const jsonData: JSONSchema = {
-    hello: 'world'
-}
-
-const o = new DynamicObject()
-
-o['hello'] = unknown.wrap('world')
-
-export function bench(title: string, code: () => void): void {
-    let ops: u32 = 100_000
-    const start: f64 = Date.now()
-    while (ops--) {
-        code()
-    }
-    const time: f64 = Date.now() - start
-    if (time <= 0) {
-        console.log(`${title}: ~${100_000 * 1000}.00 ops/s | ${Math.round((time * 100)) / 100}ms`)
-    } else {
-        console.log(`${title}: ~${Math.round(((100_000 * 1000) / time) * 100) / 100} ops/s | ${Math.round((time * 100)) / 100}ms`)
-    }
-}
-
-bench('AS-JSON Stringify String', () => {
-    JSON.stringify<string>('Hello World')
-})
-
-bench('AS-JSON Parse String', () => {
-    JSON.parse<string>('"Hello World"')
-})
-
-bench('AS-JSON Stringify Integer', () => {
-    JSON.stringify<i32>(14)
-})
-
-bench('AS-JSON Parse Integer', () => {
-    JSON.parse<i32>('14')
-})
-
-bench('AS-JSON Stringify Float', () => {
-    JSON.stringify<f64>(7.3)
-})
-
-bench('AS-JSON Parse Float', () => {
-    JSON.parse<f64>('7.3')
-})
-
-bench('AS-JSON Stringify Boolean', () => {
-    JSON.stringify<boolean>(true)
-})
-
-bench('AS-JSON Parse Boolean', () => {
-    JSON.parse<boolean>('true')
-})
-
-bench('AS-JSON Stringify Array', () => {
-    JSON.stringify<boolean[]>([true, false, true])
-})
-
-bench('AS-JSON Parse Array', () => {
-    JSON.parse<boolean[]>('[true,false,true]')
-})
-
-bench('AS-JSON Stringify Object', () => {
-    JSON.stringify<JSONSchema>(jsonData)
-})
-
-bench('AS-JSON Parse Object', () => {
-    JSON.parse<JSONSchema>('{"hello":"world"}')
-})
-
-bench('AS-JSON Stringify Dynamic Object', () => {
-    JSON.stringify<DynamicObject>(o)
-})
-
-bench('AS-JSON Parse Object', () => {
-    JSON.parse<DynamicObject>('{"hello":"world"}')
-})
-
-bench('AS-JSON Stringify Dynamic Array', () => {
-    JSON.stringify<unknown[]>(["Welcome to dynamic arrays", true])
-})
-
-bench('AS-JSON Parse Dynamic Array', () => {
-    JSON.parse<unknown[]>('["Welcome to dynamic arrays",true]')
-})
-
-bench('AS-JSON Stringify Dynamic Array', () => {
-    JSON.stringify<string[]>(["hello", "world"])
-})
-bench('AS-JSON Parse Dynamic Array', () => {
-    JSON.parse<string[]>('["hello","hello"]')
-})
-
-/*
-bench('AssemblyScript-JSON Stringify String', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.setString(null, "Hello World")
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-    // Its odd. Not encoded in UTF16 Strings.
-    // Since AS-JSON returns a string, so does assemblyscript-json in this bench.
-    // Or else, the bench is biased.
-})
-
-bench('AssemblyScript-JSON Parse String', () => {
-    const decoder: asJSON.JSON.Str = <asJSON.JSON.Str>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('"Hello World"'))))
-    decoder.valueOf()
-})
-
-bench('AssemblyScript-JSON Stringify Integer', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.setInteger(null, 14)
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-})
-
-bench('AssemblyScript-JSON Parse Integer', () => {
-    const decoder: asJSON.JSON.Integer = <asJSON.JSON.Integer>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('14'))))
-    decoder.valueOf()
-})
-
-bench('AssemblyScript-JSON Stringify Float', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.setFloat(null, 7.3)
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-})
-
-bench('AssemblyScript-JSON Parse Float', () => {
-    const decoder: asJSON.JSON.Float = <asJSON.JSON.Float>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('7.3'))))
-    decoder.valueOf()
-})
-
-bench('AssemblyScript-JSON Stringify Boolean', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.setBoolean(null, true)
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-})
-
-bench('AssemblyScript-JSON Parse Boolean', () => {
-    const decoder: asJSON.JSON.Bool = <asJSON.JSON.Bool>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('true'))))
-    decoder.valueOf()
-})
-
-bench('AssemblyScript-JSON Stringify Array', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.pushArray(null)
-    encoder.setBoolean(null, true)
-    encoder.setBoolean(null, false)
-    encoder.setBoolean(null, true)
-    encoder.popArray()
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-})
-
-bench('AssemblyScript-JSON Parse Array', () => {
-    const decoder: asJSON.JSON.Arr = <asJSON.JSON.Arr>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('[true,false,true]'))))
-    const result = decoder.valueOf()
-    const pos0: asJSON.JSON.Bool = <asJSON.JSON.Bool>result.at(0)
-    pos0.valueOf()
-    const pos1: asJSON.JSON.Bool = <asJSON.JSON.Bool>result.at(1)
-    pos1.valueOf()
-    const pos2: asJSON.JSON.Bool = <asJSON.JSON.Bool>result.at(2)
-    pos2.valueOf()
-})
-
-bench('AssemblyScript-JSON Stringify Object', () => {
-    const encoder = new asJSON.JSONEncoder()
-    encoder.pushObject(null)
-    encoder.setBoolean('bool', true)
-    encoder.popObject()
-    const binary = encoder.serialize()
-    String.UTF8.decode(binary.buffer)
-})
-
-bench('AssemblyScript-JSON Parse Object', () => {
-    const decoder: asJSON.JSON.Obj = <asJSON.JSON.Obj>(asJSON.JSON.parse(Uint8Array.wrap(String.UTF8.encode('{"bool":true}'))))
-    const result = decoder.getBool('bool')
-    if (result !== null) result.valueOf()
-})
-*/

package/assembly/unknown.ts

@@ -1,175 +0,0 @@
-export enum unknownTypes {
-    u8,
-    u16,
-    u32,
-    u64,
-    i8,
-    i16,
-    i32,
-    i64,
-    f32,
-    f64,
-    infinite,
-    boolean,
-    null,
-}
-
-// @ts-ignore
-export class unknown {
-    public value: usize = 0
-    public type: usize = 0
-    public typeName: string = ''
-    private f64: f64 = 0
-    private f32: f32 = 0
-    set<T>(data: T): void {
-        if (data instanceof usize && data === null) {
-            this.type = unknownTypes.null
-        } else if (isBoolean<T>()) {
-            this.value = data ? usize(1) : usize(0)
-            this.type = unknownTypes.boolean
-        } else if (isFloat<T>()) {
-            if (data instanceof f32) {
-                // @ts-ignore
-                this.f32 = data
-                this.type = unknownTypes.f32
-            } else {
-                // @ts-ignore
-                this.f64 = data
-                this.type = unknownTypes.f64
-            }
-        } else if (isInteger<T>()) {
-            if (isSigned<T>()) {
-                if (data instanceof i8) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.i8
-                } else if (data instanceof i16) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.i16
-                } else if (data instanceof i32) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.i32
-                } else if (data instanceof i64) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.i64
-                }
-            } else {
-                if (data instanceof u8) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.u8
-                } else if (data instanceof u16) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.u16
-                } else if (data instanceof u32) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.u32
-                } else if (data instanceof u64) {
-                    this.value = usize(data)
-                    this.type = unknownTypes.u64
-                }
-            }
-        } else {
-            this.value = changetype<usize>(data)
-            this.type = idof<T>()
-        }
-        this.typeName = nameof<T>()
-    }
-    // @ts-ignore
-    get<T>(): T {
-        let type!: T
-        if (isNullable<T>() && this.type === unknownTypes.null) {
-            // @ts-ignore
-            return null
-        } if (isBoolean<T>()) {
-            // @ts-ignore
-            if (this.value === 1) return true
-            // @ts-ignore
-            else return false
-        } else if (isFloat<T>()) {
-            if (type instanceof f32) {
-                // @ts-ignore
-                return this.f32
-            } else {
-                // @ts-ignore
-                return this.f64
-            }
-        } else if (isInteger<T>()) {
-            if (isSigned<T>()) {
-                if (type instanceof i8) {
-                    // @ts-ignore
-                    return i8(this.value)
-                } else if (type instanceof i16) {
-                    // @ts-ignore
-                    return i16(this.value)
-                } else if (type instanceof i32) {
-                    // @ts-ignore
-                    return i32(this.value)
-                } else if (type instanceof i64) {
-                    // @ts-ignore
-                    return i64(this.value)
-                }
-            } else {
-                if (type instanceof u8) {
-                    // @ts-ignore
-                    return u8(this.value)
-                } else if (type instanceof u16) {
-                    // @ts-ignore
-                    return u16(this.value)
-                } else if (type instanceof u32) {
-                    // @ts-ignore
-                    return u32(this.value)
-                } else if (type instanceof u64) {
-                    // @ts-ignore
-                    return u64(this.value)
-                }
-            }
-        } else {
-            return changetype<T>(this.value)
-        }
-    }
-    // @ts-ignore
-    is<T>(): boolean {
-        let type!: T
-        if (isBoolean<T>()) {
-            return this.type === unknownTypes.boolean
-        } else if (isFloat<T>()) {
-            if (type instanceof f32) {
-                // @ts-ignore
-                return this.type = unknownTypes.f32
-            } else {
-                // @ts-ignore
-                return this.type === unknownTypes.f64
-            }
-        } else if (isInteger<T>()) {
-            if (isSigned<T>()) {
-                if (type instanceof i8) {
-                    return this.type === unknownTypes.i8
-                } else if (type instanceof i16) {
-                    return this.type === unknownTypes.i16
-                } else if (type instanceof i32) {
-                    return this.type === unknownTypes.i32
-                } else if (type instanceof i64) {
-                    return this.type === unknownTypes.i64
-                }
-            } else {
-                if (type instanceof u8) {
-                    return this.type === unknownTypes.u8
-                } else if (type instanceof u16) {
-                    return this.type === unknownTypes.u16
-                } else if (type instanceof u32) {
-                    return this.type === unknownTypes.u32
-                } else if (type instanceof u64) {
-                    return this.type === unknownTypes.u64
-                }
-            }
-        } else if (isNullable<T>() && this.type === unknownTypes.null) {
-            return true
-        } else {
-            return this.type === idof<T>()
-        }
-    }
-    static wrap<T>(data: T): unknown {
-        const unk = new unknown()
-        unk.set(data)
-        return unk
-    }
-}

package/bench/bench.js

@@ -1,102 +0,0 @@
-const fs = require("fs");
-const loader = require("@assemblyscript/loader");
-const { WASI } = require('wasi')
-const wasiOptions = {}
-const wasi = new WASI(wasiOptions)
-const imports = {
-    wasi_snapshot_preview1: wasi.wasiImport
-};
-const wasmModule = loader.instantiateSync(fs.readFileSync(__dirname + "/output/bench.wasm"), imports);
-wasi.start(wasmModule)
-
-
-function bench(title, code) {
-    let ops = 100_000
-    const start = Date.now()
-    while (ops--) {
-        code()
-    }
-    const time = Date.now() - start
-    if (time <= 0) {
-        console.log(`${title}: ~${100_000 * 1000}.00 ops/s | ${(time * 100) / 100}ms`)
-    } else {
-        console.log(`${title}: ~${Math.round(((100_000 * 1000) / time) * 100) / 100} ops/s | ${(time * 100) / 100}ms`)
-    }
-}
-
-const jsonData = {
-    hello: "world"
-}
-
-Object
-
-bench('JSON Stringify String', () => {
-    JSON.stringify('Hello World')
-})
-
-bench('JSON Parse String', () => {
-    JSON.parse('"Hello World"')
-})
-
-bench('JSON Stringify Integer', () => {
-    JSON.stringify(14)
-})
-
-bench('JSON Parse Integer', () => {
-    JSON.parse('14')
-})
-
-bench('JSON Stringify Float', () => {
-    JSON.stringify(7.3)
-})
-
-bench('JSON Parse Float', () => {
-    JSON.parse('7.3')
-})
-
-bench('JSON Stringify Boolean', () => {
-    JSON.stringify(true)
-})
-
-bench('JSON Parse Boolean', () => {
-    JSON.parse('true')
-})
-
-bench('JSON Stringify Array', () => {
-    JSON.stringify([true, false, true])
-})
-
-bench('JSON Parse Array', () => {
-    JSON.parse('[true,false,true]')
-})
-
-bench('JSON Stringify Object', () => {
-    JSON.stringify(jsonData)
-})
-
-bench('JSON Parse Object', () => {
-    JSON.parse('{"hello":"world"}')
-})
-
-bench('JSON Stringify Dynamic Object', () => {
-    JSON.stringify(jsonData)
-})
-
-bench('JSON Parse Object', () => {
-    JSON.parse('{"hello":"world"}')
-})
-
-bench('JSON Stringify Dynamic Array', () => {
-    JSON.stringify(["Welcome to dynamic arrays", true])
-})
-
-bench('JSON Parse Dynamic Array', () => {
-    JSON.parse('["Welcome to dynamic arrays",true]')
-})
-
-bench('JSON Stringify Dynamic Array', () => {
-    JSON.stringify(["hello", "world"])
-})
-bench('JSON Parse Dynamic Array', () => {
-    JSON.parse('["hello","hello"]')
-})