json-as 0.5.51 → 0.5.54

package/.github/workflows/nodejs.yml

@@ -0,0 +1,25 @@
+name: Node.js CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v2
+
+      - name: Install dependencies
+        if: steps.node-cache.outputs.cache-hit != 'true'
+        run: yarn
+
+      - name: Test to see if the project compiles
+        run: yarn build:test
+
+      - name: Perform tests
+        run: yarn run test:aspect

package/LICENSE

@@ -1,21 +1,21 @@
-    MIT License
+MIT License
 
-    Copyright (c) 2023 Jairus Tanaka <jairus.v.tanaka@outlook.com>
+Copyright (c) 2023 Jairus Tanaka <jairus.v.tanaka@outlook.com>
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -68,29 +68,6 @@ const stringified = JSON.stringify<Player>(player);
 const parsed = JSON.parse<Player>(stringified);
 ```
 
-## Deviations from the spec
-
-This implementation does not hold strongly to the JSON specification. Rather, design and behavior are inspired by the JSON implementation found in Google's v8 engine.
-
-- No support for dynamic types
-- Unsafe by design--parser assumes valid JSON
-- Partial whitespace support--parser prefers speed over handling whitespace effectively. Users may use the `removeWhitespace` function provided by `json-as/src/util.ts`
-- Is not based off of the official spec, but rather the behavior of the JSON C implementation found in google's v8 engine
-- Support for scientific notation on integers. Float support coming soon.
-
-## Implemented features
-
-Fully supports:
-
-- Strings
-- Integers
-- Floats (Scientific notation not implemented)
-- Booleans
-- Arrays
-- Objects
-- Date
-- Null
-
 ## Performance
 
 Here are some benchmarks I took with `tinybench` (JavaScript) and `astral` (AssemblyScript).

package/assembly/__benches__/as-json.ts

@@ -1,64 +1,10 @@
 import { JSON } from "..";
-import { backSlashCode, quoteCode } from "../src/chars";
-import { atoi_fast, parseSciInteger, unsafeCharCodeAt } from "../src/util";
-import { HASH } from "util/hash";
-
-
-let last = 1;
-let char = 0;
-let inStr = false;
-let key: string | null = null;
-let pos = 0;
-
+import { snip_fast } from "../src/util";
 @json
 class Vec3 {
   x: i32;
   y: i32;
   z: i32;
-  @inline __JSON_Deserialize(
-    data: string,
-    to: Vec3
-  ): Vec3 {
-    for (; pos < data.length - 1; pos++) {
-      char = unsafeCharCodeAt(data, pos);
-      if (inStr === false && char === quoteCode) {
-        if (key != null) {
-          if (unsafeCharCodeAt(key!, 0) == 120) {
-            to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key!, 0) == 121) {
-            to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-          } else if (unsafeCharCodeAt(key!, 0) == 122) {
-            to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
-          }
-        }
-        last = ++pos;
-        inStr = true;
-      } else if (
-        char === quoteCode &&
-        unsafeCharCodeAt(data, pos - 1) != backSlashCode
-      ) {
-        inStr = false;
-        key = data.substring(last, pos);
-        last = pos += 2;
-      }
-    }
-    if (key != null) {
-      if (unsafeCharCodeAt(key!, 0) == 120) {
-        to.x = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key!, 0) == 121) {
-        to.y = parseSciInteger<i32>(data.substring(last, pos - 1));
-      } else if (unsafeCharCodeAt(key!, 0) == 122) {
-        to.z = parseSciInteger<i32>(data.substring(last, pos - 1));
-      }
-    }
-
-    last = 1;
-    char = 0;
-    inStr = false;
-    key = null;
-    pos = 0;
-    return to;
-  }
 }
 
 const vec: Vec3 = {
@@ -66,15 +12,31 @@ const vec: Vec3 = {
   y: 1,
   z: 8,
 }
+
+bench("Parse Number SNIP", () => {
+  blackbox<i32>(snip_fast<i32>("12345"));
+});
 /*
+bench("Parse Number ATOI", () => {
+  blackbox<i32>(atoi_fast<i32>("12345"));
+})
+
+bench("Parse Number STDLIB", () => {
+  blackbox<i32>(i32.parse("12345"));
+});
+
+bench("Parse Number OLD", () => {
+  blackbox<i32>(parseSciInteger<i32>("12345"));
+});
+*/
 bench("Stringify Object (Vec3)", () => {
   blackbox<string>(vec.__JSON_Serialize());
 });
 
 // TODO: Make this allocate without crashing
-bench("Parse Object (Vec3)", () => {
-  blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}', vec));
-});
+//bench("Parse Object (Vec3)", () => {
+//  blackbox<Vec3>(vec.__JSON_Deserialize('{"x":0,"y":0,"z":0}', vec));
+//});
 
 bench("Stringify Number Array", () => {
   blackbox(JSON.stringify<i32[]>([1, 2, 3]));
@@ -87,7 +49,7 @@ bench("Parse Number Array", () => {
 bench("Stringify String", () => {
   blackbox(JSON.stringify(blackbox('Hello "World!')));
 });
-*/
+
 bench("Parse String", () => {
   blackbox(JSON.parse<string>(blackbox('"Hello "World!"')));
 });
@@ -110,12 +72,12 @@ bench("Parse Boolean", () => {
 
 bench("Stringify Integer", () => {
   blackbox(JSON.stringify(blackbox(314)));
-});
+});*/
 
 bench("Parse Integer", () => {
   blackbox(JSON.parse<i32>(blackbox("314")));
 });
-
+/*
 bench("Stringify Float", () => {
   blackbox(JSON.stringify(blackbox(3.14)));
 });

package/assembly/__tests__/as-json.spec.ts

@@ -1,8 +1,8 @@
 import { JSON } from "..";
-function canSerde<T>(data: T): void {
-  const serialized = JSON.stringify<T>(data);
-  const deserialized = JSON.stringify<T>(JSON.parse<T>(serialized));
-  expect(serialized).toBe(deserialized);
+function canSerde<T>(data: T, toBe: string = ""): void {
+  if (!toBe) toBe = JSON.stringify<T>(data);
+  const deserialized = JSON.stringify<T>(JSON.parse<T>(JSON.stringify(data)));
+  expect(deserialized).toBe(toBe);
 }
 
 // @ts-ignore
@@ -46,23 +46,20 @@ describe("Ser/de Numbers", () => {
   it("should ser/de integers", () => {
     canSerde<i32>(0);
 
-    canSerde<u32>(100);
-    canSerde<u64>(101);
-    canSerde<i32>(-100);
-    canSerde<i64>(-101);
+    canSerde<u32>(100, "100");
+    canSerde<u64>(101, "101");
+    canSerde<i32>(-100, "-100");
+    canSerde<i64>(-101, "-101");
   });
 
   it("should ser/de floats", () => {
-    canSerde<f64>(7.23);
-    canSerde<f64>(10e2);
-    canSerde<f64>(10e2);
+    canSerde<f64>(7.23, "7.23");
+    canSerde<f64>(10e2, "1000.0");
 
-    canSerde<f64>(123456e-5);
+    canSerde<f64>(123456e-5, "1.23456");
 
-    canSerde<f64>(123456e-5);
-
-    canSerde<f64>(0.0);
-    canSerde<f64>(7.23);
+    canSerde<f64>(0.0, "0.0");
+    canSerde<f64>(7.23, "7.23");
   });
 
   it("should ser/de booleans", () => {
@@ -71,15 +68,6 @@ describe("Ser/de Numbers", () => {
     canSerde<boolean>(true);
     canSerde<boolean>(false);
   });
-
-  it("should ser/de BigInt objects", () => {
-    canSerde<i32>(0);
-
-    canSerde<u32>(100);
-    canSerde<u64>(101);
-    canSerde<i32>(-100);
-    canSerde<i64>(-101);
-  });
 });
 
 describe("Ser/de Array", () => {
@@ -161,6 +149,6 @@ describe("Ser/de Objects", () => {
         z: 8.3,
       },
       isVerified: true,
-    });
+    }, '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
   });
 });

package/assembly/src/json.ts

@@ -1,5 +1,5 @@
 import { StringSink } from "as-string-sink/assembly";
-import { isSpace, CharCode } from "util/string";
+import { isSpace } from "util/string";
 import {
   backSlashCode,
   commaCode,
@@ -21,7 +21,7 @@ import {
   uCode,
   emptyArrayWord,
 } from "./chars";
-import { parseSciInteger, unsafeCharCodeAt } from "./util";
+import { snip_fast, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
@@ -35,14 +35,11 @@ export namespace JSON {
    * @param data T
    * @returns string
    */
-  // @ts-ignore
-  @inline export function stringify<
-    T
-  >(data: T): string {
+  // @ts-ignore: Decorator
+  @inline export function stringify<T>(data: T): string {
     // String
     if (isString<T>() && data != null) {
-      // @ts-ignore
-      return serializeString(data);
+      return serializeString(data as string);
     } else if (isBoolean<T>()) {
       return data ? "true" : "false";
     } else if (isNullable<T>() && data == null) {
@@ -51,9 +48,9 @@ export namespace JSON {
     } else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
       // @ts-ignore
       return data.toString();
-      // @ts-ignore
+      // @ts-ignore: Hidden function
     } else if (isDefined(data.__JSON_Serialize)) {
-      // @ts-ignore
+      // @ts-ignore: Hidden function
       return data.__JSON_Serialize();
     } else if (data instanceof Date) {
       return data.toISOString();
@@ -110,10 +107,8 @@ export namespace JSON {
    * @returns T
    */
 
-  // @ts-ignore
-  @inline export function parse<
-    T
-  >(data: string): T {
+  // @ts-ignore: Decorator
+  @inline export function parse<T>(data: string): T {
     let type: T;
     if (isString<T>()) {
       // @ts-ignore
@@ -143,20 +138,17 @@ export namespace JSON {
       );
     }
   }
-  // @ts-ignore
-  @inline function parseObjectValue<
-    T
-  >(data: string): T {
+  // @ts-ignore: Decorator
+  @inline function parseObjectValue<T>(data: string): T {
     let type: T;
     if (isString<T>()) {
       // @ts-ignore
       let result = "";
       let last = 0;
-      let char = 0;
       for (let i = 0; i < data.length; i++) {
         // \\"
         if (unsafeCharCodeAt(data, i) === backSlashCode) {
-          char = unsafeCharCodeAt(data, ++i);
+          const char = unsafeCharCodeAt(data, ++i);
           result += data.slice(last, i - 1);
           if (char === 34) {
             result += '"';
@@ -184,7 +176,7 @@ export namespace JSON {
             } else if (
               char === 117 &&
               load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
-                27584753879220272
+              27584753879220272
             ) {
               result += "\u000b";
               i += 4;
@@ -223,10 +215,8 @@ export namespace JSON {
   }
 }
 
-// @ts-ignore
-@inline function serializeString(
-  data: string
-): string {
+// @ts-ignore: Decorator
+@inline function serializeString(data: string): string {
   // @ts-ignore
   //if (data.length === 0) return "\"\"";
   /*
@@ -309,10 +299,8 @@ export namespace JSON {
   return result + '"';
 }
 
-// @ts-ignore
-@inline function parseString(
-  data: string
-): string {
+// @ts-ignore: Decorator
+@inline function parseString(data: string): string {
   let result = "";
   let last = 1;
   for (let i = 1; i < data.length - 1; i++) {
@@ -359,7 +347,7 @@ export namespace JSON {
             if (
               char === 117 &&
               load<u64>(changetype<usize>(data) + <usize>((i + 1) << 1)) ===
-                27584753879220272
+              27584753879220272
             ) {
               result += "\u000b";
               i += 4;
@@ -375,22 +363,18 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseBoolean<
-  T extends boolean
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseBoolean<T extends boolean>(data: string): T {
   if (data.length > 3 && data.startsWith("true")) return <T>true;
   else if (data.length > 4 && data.startsWith("false")) return <T>false;
   else throw new Error(`JSON: Cannot parse "${data}" as boolean`);
 }
 
-// @ts-ignore
-@inline export function parseNumber<
-  T
->(data: string): T {
+// @ts-ignore: Decorator
+@inline export function parseNumber<T>(data: string): T {
   if (isInteger<T>()) {
     // @ts-ignore
-    return parseSciInteger<T>(data);
+    return snip_fast<T>(data);
   }
   // @ts-ignore
   const type: T = 0;
@@ -400,27 +384,24 @@ export namespace JSON {
   else if (type instanceof f32) return f32.parse(data);
 }
 
-// @ts-ignore
-@inline function parseObject<
-  T
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseObject<T>(data: string): T {
   let schema: nonnull<T> = changetype<nonnull<T>>(
     __new(offsetof<nonnull<T>>(), idof<nonnull<T>>())
   );
   let key = "";
   let isKey = false;
   let depth = 0;
-  let char = 0;
   let outerLoopIndex = 1;
   for (; outerLoopIndex < data.length - 1; outerLoopIndex++) {
-    char = unsafeCharCodeAt(data, outerLoopIndex);
+    const char = unsafeCharCodeAt(data, outerLoopIndex);
     if (char === leftBracketCode) {
       for (
         let arrayValueIndex = outerLoopIndex;
         arrayValueIndex < data.length - 1;
         arrayValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, arrayValueIndex);
+        const char = unsafeCharCodeAt(data, arrayValueIndex);
         if (char === leftBracketCode) {
           depth++;
         } else if (char === rightBracketCode) {
@@ -444,7 +425,7 @@ export namespace JSON {
         objectValueIndex < data.length - 1;
         objectValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, objectValueIndex);
+        const char = unsafeCharCodeAt(data, objectValueIndex);
         if (char === leftBraceCode) {
           depth++;
         } else if (char === rightBraceCode) {
@@ -468,7 +449,7 @@ export namespace JSON {
         stringValueIndex < data.length - 1;
         stringValueIndex++
       ) {
-        char = unsafeCharCodeAt(data, stringValueIndex);
+        const char = unsafeCharCodeAt(data, stringValueIndex);
         if (
           char === quoteCode &&
           unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
@@ -514,7 +495,7 @@ export namespace JSON {
     } else if ((char >= 48 && char <= 57) || char === 45) {
       let numberValueIndex = ++outerLoopIndex;
       for (; numberValueIndex < data.length; numberValueIndex++) {
-        char = unsafeCharCodeAt(data, numberValueIndex);
+        const char = unsafeCharCodeAt(data, numberValueIndex);
         if (char === commaCode || char === rightBraceCode || isSpace(char)) {
           // @ts-ignore
           schema.__JSON_Set_Key(
@@ -531,10 +512,8 @@ export namespace JSON {
   return schema;
 }
 
-// @ts-ignore
-@inline function parseArray<
-  T extends unknown[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseArray<T extends unknown[]>(data: string): T {
   if (isString<valueof<T>>()) {
     return <T>parseStringArray(data);
   } else if (isBoolean<valueof<T>>()) {
@@ -562,10 +541,8 @@ export namespace JSON {
   return unreachable();
 }
 
-// @ts-ignore
-@inline function parseStringArray(
-  data: string
-): string[] {
+// @ts-ignore: Decorator
+@inline function parseStringArray(data: string): string[] {
   const result: string[] = [];
   let lastPos = 0;
   let instr = false;
@@ -583,15 +560,12 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseBooleanArray<
-  T extends boolean[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseBooleanArray<T extends boolean[]>(data: string): T {
   const result = instantiate<T>();
   let lastPos = 1;
-  let char = 0;
   for (let i = 1; i < data.length - 1; i++) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     /*// if char == "t" && i+3 == "e"
                 if (char === tCode && data.charCodeAt(i + 3) === eCode) {
                   //i += 3;
@@ -612,16 +586,13 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseNumberArray<
-  T extends number[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseNumberArray<T extends number[]>(data: string): T {
   const result = instantiate<T>();
   let lastPos = 0;
-  let char = 0;
   let i = 1;
   for (; i < data.length - 1; i++) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if ((lastPos === 0 && char >= 48 && char <= 57) || char === 45) {
       lastPos = i;
     } else if ((isSpace(char) || char == commaCode) && lastPos > 0) {
@@ -630,7 +601,7 @@ export namespace JSON {
     }
   }
   for (; i > lastPos - 1; i--) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if (char !== rightBracketCode) {
       result.push(parseNumber<valueof<T>>(data.slice(lastPos, i + 1)));
       break;
@@ -639,12 +610,9 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline function parseArrayArray<
-  T extends unknown[][]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline function parseArrayArray<T extends unknown[][]>(data: string): T {
   const result = instantiate<T>();
-  let char = 0;
   let lastPos = 0;
   let depth = 0;
   let i = 1;
@@ -652,7 +620,7 @@ export namespace JSON {
   //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
   //i++;
   for (; i < data.length - 1; i++) {
-    char = unsafeCharCodeAt(data, i);
+    const char = unsafeCharCodeAt(data, i);
     if (char === leftBracketCode) {
       if (depth === 0) {
         lastPos = i;
@@ -670,16 +638,13 @@ export namespace JSON {
   return result;
 }
 
-// @ts-ignore
-@inline export function parseObjectArray<
-  T extends unknown[]
->(data: string): T {
+// @ts-ignore: Decorator
+@inline export function parseObjectArray<T extends unknown[]>(data: string): T {
   const result = instantiate<T>();
-  let char = 0;
   let lastPos: u32 = 1;
   let depth: u32 = 0;
   for (let pos: u32 = 0; pos < <u32>data.length; pos++) {
-    char = unsafeCharCodeAt(data, pos);
+    const char = unsafeCharCodeAt(data, pos);
     if (char === leftBraceCode) {
       if (depth === 0) {
         lastPos = pos;