json-as 0.4.3 → 0.4.6

package/assembly/index.ts

@@ -1,21 +1,48 @@
 import { StringSink } from "as-string-sink/assembly";
 import { Variant } from "as-variant/assembly";
+import { isSpace } from "assemblyscript/std/assembly/util/string";
+import { stringify } from "as-console/assembly";
 import {
   backSlashCode,
   colonCode,
   commaCode,
+  eCode,
+  fCode,
+  forwardSlashCode,
   leftBraceCode,
   leftBracketCode,
   quoteCode,
   rightBraceCode,
-  rightBracketCode
+  rightBracketCode,
+  tCode,
 } from "./chars";
+import { removeWhitespace, unsafeCharCodeAt } from "./util";
 
 /**
  * JSON Encoder/Decoder for AssemblyScript
  */
-export namespace JSON {
-  export type _Variant = Variant;
+export class JSON {
+  private static parseObjectValue<T>(data: string): T {
+    let type!: T;
+    if (isString<T>()) {
+      // @ts-ignore
+      return data.replaceAll('\\"', '"');
+    } else if (isBoolean<T>()) {
+      // @ts-ignore
+      return parseBoolean<T>(data);
+    } else if (isFloat<T>() || isInteger<T>()) {
+      return parseNumber<T>(data);
+    } else if (isArrayLike<T>()) {
+      // @ts-ignore
+      return parseArray<T>(data);
+      // @ts-ignore
+    } else if (isDefined(type.__JSON_Deserialize)) {
+      return parseObject<T>(data);
+    } else {
+      // @ts-ignore
+      return null;
+    }
+  }
   /**
    * Stringifies valid JSON data.
    * ```js
@@ -24,7 +51,7 @@ export namespace JSON {
    * @param data T
    * @returns string
    */
-  export function stringify<T = Nullable | null>(data: T): string {
+  static stringify<T = Nullable | null>(data: T): string {
     // String
     if (isString<T>()) {
       return '"' + (<string>data).replaceAll('"', '\\"') + '"';
@@ -76,7 +103,7 @@ export namespace JSON {
    * @param data string
    * @returns T
    */
-  export function parse<T = Variant>(data: string): T {
+  static parse<T = Variant>(data: string): T {
     let type!: T;
     if (isString<T>()) {
       // @ts-ignore
@@ -87,53 +114,11 @@ export namespace JSON {
     } else if (isFloat<T>() || isInteger<T>()) {
       return parseNumber<T>(data);
     } else if (isArrayLike<T>()) {
-      return parseArray<T>(data);
       // @ts-ignore
-    } else if (isDefined(type.__JSON_Deserialize)) {
-      const len: u32 = data.length - 1
-      let schema!: T
-      const result = new Map<string, string>()
-      let lastPos: u32 = 1
-      let key: string = ''
-      let instr: boolean = false
-      let char: u32 = 0
-      let depth: u32 = 0
-      let fdepth: u32 = 0
-      for (let i: u32 = 1; i < len; i++) {
-        char = data.charCodeAt(i);
-        if (instr === false && char === quoteCode) instr = true;
-        else if (instr === true && char === quoteCode && data.charCodeAt(i - 1) !== "/".charCodeAt(0)) instr = false;
-        if (instr === false) {
-          if (char === leftBraceCode || char === leftBracketCode) depth++
-          if (char === rightBraceCode || char === rightBracketCode) fdepth++
-        }
-        if (depth !== 0 && depth === fdepth) {
-          //console.log(`Found Struct: ${data.slice(lastPos + 1, i + 1)}`)
-          result.set(key, data.slice(lastPos + 1, i + 1))
-          // Reset the depth
-          depth = 0
-          fdepth = 0
-          // Set new lastPos
-          lastPos = i + 1
-        }
-        if (!instr && depth === 0) {
-          if (char === colonCode) {
-            key = data.slice(lastPos + 1, i - 1)
-           //console.log(`Found Key: ${data.slice(lastPos + 1, i - 1)}`)
-            lastPos = i
-          } else if (char === commaCode) {
-            //console.log(`Found Comma: ${data.slice(lastPos + 1, i)}`)
-            if ((i - lastPos) > 0) result.set(key, data.slice(lastPos + 1, i))
-            lastPos = i + 1
-          }
-        }
-      }
-
-      if ((len - lastPos) > 1 && (len - lastPos) !== 0) {
-        result.set(key, data.slice(lastPos + 1, len))
-      }
+      return parseArray<T>(data.trimStart());
       // @ts-ignore
-      return schema.__JSON_Deserialize(result)
+    } else if (isDefined(type.__JSON_Deserialize)) {
+      return parseObject<T>(data.trimStart());
     } else {
       // @ts-ignore
       return null;
@@ -141,23 +126,23 @@ export namespace JSON {
   }
 }
 
-
 // @ts-ignore
 @inline
-  function parseString(data: string): string {
+function parseString(data: string): string {
   return data.slice(1, data.length - 1).replaceAll('\\"', '"');
 }
 
 // @ts-ignore
 @inline
-  function parseBoolean<T extends boolean>(data: string): T {
+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
-  function parseNumber<T>(data: string): T {
+function parseNumber<T>(data: string): T {
   let type: T;
   // @ts-ignore
   if (type instanceof f64) return F64.parseFloat(data);
@@ -183,127 +168,287 @@ export namespace JSON {
 
 // @ts-ignore
 @inline
-  export function parseNumberArray<T>(data: string): T {
-  const result = instantiate<T>();
-  if (data.length == 0) return result;
-  let lastPos: u32 = 1;
-  let i: u32 = 1;
-  let char: u32 = 0;
-  for (; i < u32(data.length - 1); i++) {
-    char = data.charCodeAt(i);
-    if (char == commaCode) {
-      // console.log(data.slice(lastPos, i))
-      // @ts-ignore
-      result.push(parseNumber<valueof<T>>(data.slice(lastPos, i).trim()));
-      lastPos = ++i;
+export function parseObject<T>(data: string): T {
+  let schema!: T;
+  const result = new Map<string, string>();
+  let key: usize = 0;
+  let depth = 1;
+  let char = 0;
+  for (
+    let outerLoopIndex = 1;
+    outerLoopIndex < data.length - 1;
+    outerLoopIndex++
+  ) {
+    char = unsafeCharCodeAt(data, outerLoopIndex);
+    if (char === leftBracketCode) {
+      for (
+        let arrayValueIndex = outerLoopIndex;
+        arrayValueIndex < data.length - 1;
+        arrayValueIndex++
+      ) {
+        char = unsafeCharCodeAt(data, arrayValueIndex);
+        if (char === leftBracketCode) {
+          depth = depth << 1;
+        } else if (char === rightBracketCode) {
+          depth = depth >> 1;
+          if (depth === 1) {
+            ++arrayValueIndex;
+            result.set(
+              changetype<string>(key),
+              data.slice(outerLoopIndex, arrayValueIndex)
+            );
+            outerLoopIndex = arrayValueIndex;
+            key = 0;
+            break;
+          }
+        }
+      }
+    } else if (char === leftBraceCode) {
+      for (
+        let objectValueIndex = outerLoopIndex;
+        objectValueIndex < data.length - 1;
+        objectValueIndex++
+      ) {
+        char = unsafeCharCodeAt(data, objectValueIndex);
+        if (char === leftBraceCode) {
+          depth = depth << 1;
+        } else if (char === rightBraceCode) {
+          depth = depth >> 1;
+          if (depth === 1) {
+            ++objectValueIndex;
+            result.set(
+              changetype<string>(key),
+              data.slice(outerLoopIndex, objectValueIndex)
+            );
+            outerLoopIndex = objectValueIndex;
+            key = 0;
+            break;
+          }
+        }
+      }
+    } else if (char === quoteCode) {
+      for (
+        let stringValueIndex = ++outerLoopIndex;
+        stringValueIndex < data.length - 1;
+        stringValueIndex++
+      ) {
+        char = unsafeCharCodeAt(data, stringValueIndex);
+        if (
+          char === quoteCode &&
+          unsafeCharCodeAt(data, stringValueIndex - 1) !== backSlashCode
+        ) {
+          if (key === 0) {
+            key = changetype<usize>(
+              data.slice(outerLoopIndex, stringValueIndex)
+            );
+          } else {
+            result.set(
+              changetype<string>(key),
+              data.slice(outerLoopIndex, stringValueIndex)
+            );
+            key = 0;
+          }
+          outerLoopIndex = ++stringValueIndex;
+          break;
+        }
+      }
+    } else if (
+      char === tCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === "r".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === "u".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+    ) {
+      result.set(changetype<string>(key), "true");
+      key = 0;
+    } else if (
+      char === fCode &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === "a".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === "l".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === "s".charCodeAt(0) &&
+      unsafeCharCodeAt(data, ++outerLoopIndex) === eCode
+    ) {
+      result.set(changetype<string>(key), "false");
+      key = 0;
+    } else if (char >= 48 && char <= 57) {
+      let numberValueIndex = ++outerLoopIndex;
+      for (; numberValueIndex < data.length - 1; numberValueIndex++) {
+        char = unsafeCharCodeAt(data, numberValueIndex);
+        if (
+          char === commaCode ||
+          isSpace(char) ||
+          numberValueIndex == data.length - 2
+        ) {
+          result.set(
+            changetype<string>(key),
+            data.slice(outerLoopIndex - 1, numberValueIndex)
+          );
+          outerLoopIndex = numberValueIndex;
+          key = 0;
+          break;
+        }
+      }
     }
   }
-  //console.log(data.slice(lastPos, data.length - 1))
   // @ts-ignore
-  result.push(
+  return schema.__JSON_Deserialize(result);
+}
+
+// @ts-ignore
+@inline
+// @ts-ignore
+export function parseArray<T extends unknown[]>(data: string): T {
+  // TODO: Replace with opt
+  let type!: valueof<T>;
+  if (type instanceof String) {
+    return <T>parseStringArray(data);
+  } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+    // @ts-ignore
+    return parseNumberArray<T>(data);
+  } else if (isBoolean<valueof<T>>()) {
+    // @ts-ignore
+    return parseBooleanArray<T>(data);
+  } else if (isArrayLike<valueof<T>>()) {
     // @ts-ignore
-    parseNumber<valueof<T>>(data.slice(lastPos, data.length - 1).trimStart())
-  );
+    return parseArrayArray<T>(data);
+    // @ts-ignore
+  } else if (isDefined(type.__JSON_Deserialize)) {
+    // @ts-ignore
+    return parseObjectArray<T>(data);
+  }
+}
+
+// @ts-ignore
+@inline
+export function parseStringArray(data: string): string[] {
+  const result: string[] = [];
+  let lastPos = 0;
+  let instr = false;
+  for (let i = 1; i < data.length - 1; i++) {
+    if (unsafeCharCodeAt(data, i) === quoteCode) {
+      if (instr === false) {
+        instr = true;
+        lastPos = i;
+      } else if (unsafeCharCodeAt(data, i - 1) !== backSlashCode) {
+        instr = false;
+        result.push(data.slice(lastPos + 1, i).replaceAll('\\"', '"'));
+      }
+    }
+  }
   return result;
 }
 
 // @ts-ignore
 @inline
-  export function parseBooleanArray<T>(data: string): T {
+export function parseBooleanArray<T extends boolean[]>(data: string): T {
   const result = instantiate<T>();
-  if (data.length == 0) return result;
-  let lastPos: u32 = 1;
-  let i: u32 = 1;
-  let char: u32 = 0;
-  for (; i < u32(data.length - 1); i++) {
-    char = data.charCodeAt(i);
-    if (char == commaCode) {
-      // @ts-ignore
-      result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i).trimStart()));
-      lastPos = ++i;
+  let lastPos = 1;
+  let char = 0;
+  for (let i = 1; i < data.length - 1; i++) {
+    char = unsafeCharCodeAt(data, i);
+    /*// if char == "t" && i+3 == "e"
+    if (char === tCode && data.charCodeAt(i + 3) === eCode) {
+      //i += 3;
+      result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+2)));
+      //i++;
+    } else if (char === fCode && data.charCodeAt(i + 4) === eCode) {
+      //i += 4;
+      result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i+3)));
+      //i++;
+    }*/
+    if (char === tCode || char === fCode) {
+      lastPos = i;
+    } else if (char === eCode) {
+      i++;
+      result.push(parseBoolean<valueof<T>>(data.slice(lastPos, i)));
     }
   }
-  // @ts-ignore
-  result.push(
-    // @ts-ignore
-    parseBoolean<valueof<T>>(data.slice(lastPos, data.length - 1).trimStart())
-  );
   return result;
 }
 
 // @ts-ignore
 @inline
-  export function parseArray<T>(data: string): T {
+export function parseNumberArray<T extends number[]>(data: string): T {
   const result = instantiate<T>();
-  data = data.trim();
-  let len: u32 = data.length - 1;
-  let lastPos: u32 = 1;
-  let i: u32 = 1;
-  let char: u32 = 0;
-  // Is struct such as Object, or Array
-  let isStruct: boolean = false;
-  let isStr: boolean = false;
-  //let offset: u32 = 0;
-  // Depth for finding matching brackets
-  let inDepth: u32 = 0;
-  let outDepth: u32 = 0;
-  for (; i < len; i++) {
-    char = data.charCodeAt(i);
-    if (char == quoteCode && data.charCodeAt(i - 1) != backSlashCode)
-      isStr = !isStr;
-    if (char == leftBraceCode || char == leftBracketCode) {
-      inDepth++;
-      isStruct = true;
-    } else if (char == rightBraceCode || char == rightBracketCode) {
-      outDepth++;
-      isStruct = true;
+  let lastPos = 0;
+  let char = 0;
+  let i = 1;
+  for (; i < data.length - 1; i++) {
+    char = unsafeCharCodeAt(data, i);
+    if (lastPos === 0 && char >= 48 && char <= 57) {
+      lastPos = i;
+    } else if ((isSpace(char) || char == commaCode) && lastPos > 0) {
+      result.push(parseNumber<valueof<T>>(data.slice(lastPos, i)));
+      lastPos = 0;
     }
-    if (!isStr) {
-      if (!isStruct) {
-        // This removes whitespace before and after an element
-        /*if (offset != 0 && isSpace(char)) {
-          lastPos++;
-        } else {
-          if (isSpace(char)) offset++;
-        }*/
-        // This checks to see if we are dealing with structures such as Objects and Arrays
-        if (char == commaCode) {
-          // @ts-ignore
-          result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i).trim()));
-          //offset = 0;
-          lastPos = i + 1;
-        }
-      } else {
-        if (inDepth == outDepth) {
-          i++;
-          //console.log(`Struct-${data.slice(lastPos, i).trim()}-`)
-          lastPos = i + 1;
-          inDepth = 0;
-          outDepth = 0;
-          isStruct = false;
-        }
-      }
+  }
+  for (; i > lastPos; i--) {
+    char = unsafeCharCodeAt(data, i);
+    if (char !== rightBracketCode) {
+      result.push(parseNumber<valueof<T>>(data.slice(lastPos, i + 1)));
+      break;
     }
   }
-  /*char = data.charCodeAt(lastPos)
-  // Remove preceeding whitespace
-  while (isSpace(char)) {
-    lastPos++;
-    char = data.charCodeAt(lastPos);
+  return result;
+}
+
+// @ts-ignore
+@inline
+export function parseArrayArray<T extends unknown[][]>(data: string): T {
+  const result = instantiate<T>();
+  let char = 0;
+  let lastPos = 0;
+  let depth = 1;
+  let i = 1;
+  // Find start of bracket
+  //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) {}
+  //i++;
+  for (; i < data.length - 1; i++) {
+    char = unsafeCharCodeAt(data, i);
+    if (char === leftBracketCode) {
+      if (depth === 1) {
+        lastPos = i;
+      }
+      // Shifting is 6% faster than incrementing
+      depth = depth << 1;
+    } else if (char === rightBracketCode) {
+      depth = depth >> 1;
+      if (depth === 1) {
+        i++;
+        result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+      }
+    }
   }
-  char = data.charCodeAt(--len);
-  while (isSpace(char)) {
-    len--;
-    char = data.charCodeAt(len);
-  }*/
+  return result;
+}
 
-  // @ts-ignore
-  // Handle empty arrays
-  data = data.slice(lastPos, len).trim();
-  // @ts-ignore
-  if (data.length != 0) result.push(JSON.parse<valueof<T>>(data));
-  //if (data.length != 0) console.log(`Trailing-${data.slice(lastPos, len).trim()}-`)
+// @ts-ignore
+@inline
+export function parseObjectArray<T extends unknown[][]>(data: string): T {
+  const result = instantiate<T>();
+  let char = 0;
+  let lastPos = 1;
+  let depth = 1;
+  let i = 1;
+  // Find start of bracket
+  //for (; unsafeCharCodeAt(data, i) !== leftBracketCode; i++) { }
+  //i++;
+  for (; i < data.length - 1; i++) {
+    char = unsafeCharCodeAt(data, i);
+    if (char === leftBraceCode) {
+      if (depth === 1) {
+        lastPos = i;
+      }
+      // Shifting is 6% faster than incrementing
+      depth = depth << 1;
+    } else if (char === rightBraceCode) {
+      depth = depth >> 1;
+      if (depth === 1) {
+        i++;
+        result.push(JSON.parse<valueof<T>>(data.slice(lastPos, i)));
+      }
+    }
+  }
   return result;
 }
 
-class Nullable { }
+class Nullable {}

package/assembly/test.ts

@@ -1,57 +1,49 @@
 import "wasi";
-import { JSON } from ".";
+import {
+  JSON
+} from ".";
 
 // @ts-ignore
 @json
 class Vec2 {
-  x: f32
-  y: f32
+  x: f32;
+  y: f32;
 }
 
 // @ts-ignore
 @json
 class Player {
-  firstName: string
-  lastName: string
-  lastActive: i32[]
-  age: i32
-  pos: Vec2
+  firstName: string;
+  lastName: string;
+  lastActive: i32[];
+  age: i32;
+  pos: Vec2;
+  isVerified: boolean;
 }
 
-const data: Player = {
+const player: Player = {
   firstName: "Emmet",
   lastName: "West",
   lastActive: [8, 27, 2022],
   age: 23,
   pos: {
     x: -3.4,
-    y: 1.2
-  }
+    y: 1.2,
+  },
+  isVerified: true,
+};
+
+const vec: Vec2 = {
+  x: 0.0,
+  y: 0.0
 }
+const serializedPlayer = JSON.stringify<Player>(player);
+console.log("Serialized Player: " + serializedPlayer);
+const deserializedPlayer = JSON.parse<Player>(serializedPlayer);
+console.log("Deserialized Player: " + JSON.stringify(deserializedPlayer));
+
+const serializedVec2 = JSON.stringify<Vec2>(vec);
+console.log("Serialized Vec2: " + serializedVec2);
+const deserializedVec2 = JSON.parse<Vec2>(serializedVec2);
 
-const stringified = JSON.stringify<Player>(data);
-// {
-//  "firstName": "Emmet",
-//  "lastName": "West",
-// "lastActive": [8, 27, 2022],
-//  "age": 23,
-//  "pos": {
-//    "x": -3.4000000953674318,
-//    "y": 1.2000000476837159
-//  }
-// }
-console.log(`Stringified: ${stringified}`);
-data.age = 16
-console.log(`Stringified2: ${JSON.stringify<Player>(data)}`);
-const parsed = JSON.parse<Player>(stringified);
-// Player {
-//  firstName: "Emmet",
-//  lastName: "West",
-//  lastActive: [8, 27, 2022],
-//  age: 23,
-//  pos: {
-//    x: -3.4000000953674318,
-//    y: 1.2000000476837159
-//  }
-// }
-console.log(`Parsed: ${JSON.stringify(parsed)}`);
+console.log("Deserialized: " + JSON.stringify(deserializedVec2));

package/assembly/util.ts

@@ -1,14 +1,30 @@
-export function isNumberCode(data: i32): boolean {
-    if (data == "0".charCodeAt(0)) return true;
-    else if (data == "1".charCodeAt(0)) return true;
-    else if (data == "2".charCodeAt(0)) return true;
-    else if (data == "3".charCodeAt(0)) return true;
-    else if (data == "4".charCodeAt(0)) return true;
-    else if (data == "5".charCodeAt(0)) return true;
-    else if (data == "6".charCodeAt(0)) return true;
-    else if (data == "7".charCodeAt(0)) return true;
-    else if (data == "8".charCodeAt(0)) return true;
-    else if (data == "9".charCodeAt(0)) return true;
-    else if (data == "-".charCodeAt(0)) return true;
-    else return false;
-}
+import { StringSink } from "as-string-sink/assembly";
+import { isSpace } from "assemblyscript/std/assembly/util/string";
+import { backSlashCode, quoteCode } from "./chars";
+// @ts-ignore
+@inline
+export function unsafeCharCodeAt(data: string, pos: i32): i32 {
+  return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
+}
+
+export function removeWhitespace(data: string): string {
+  const result = new StringSink();
+  let instr = false;
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i);
+    if (instr === false && char === quoteCode) instr = true;
+    else if (
+      instr === true &&
+      char === quoteCode &&
+      data.charCodeAt(i - 1) !== backSlashCode
+    )
+      instr = false;
+
+    if (instr === false) {
+      if (!isSpace(char)) result.write(data.charAt(i));
+    } else {
+      result.write(data.charAt(i));
+    }
+  }
+  return result.toString();
+}

package/index.ts

@@ -1 +0,0 @@
-export { JSON } from "./assembly/index";