json-as 0.4.2 → 0.4.5

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,19 +51,15 @@ 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(data)) {
-      return serializeString(<string>data);
+    if (isString<T>()) {
+      return '"' + (<string>data).replaceAll('"', '\\"') + '"';
     }
     // Boolean
-    else if (isBoolean(data)) {
+    else if (isBoolean<T>()) {
       return data ? "true" : "false";
     }
-    // Null
-    else if (isNullable<T>() && data == null) {
-      return "null";
-    }
     // Integers/Floats
     // @ts-ignore
     else if ((isInteger<T>() || isFloat<T>()) && isFinite(data)) {
@@ -46,20 +69,28 @@ export namespace JSON {
     // Class-Based serialization
     // @ts-ignore
     else if (isDefined(data.__JSON_Serialize)) {
-      //@ts-ignore
+      // @ts-ignore
       return data.__JSON_Serialize();
     }
     // ArrayLike
-    else if (isArrayLike(data)) {
+    else if (isArrayLike<T>()) {
       let result = new StringSink("[");
+      // @ts-ignore
       if (data.length == 0) return "[]";
+      // @ts-ignore
       for (let i = 0; i < data.length - 1; i++) {
+        // @ts-ignore
         result.write(stringify(unchecked(data[i])));
         result.write(",");
       }
+      // @ts-ignore
       result.write(stringify(unchecked(data[data.length - 1])));
       result.write("]");
       return result.toString();
+    }
+    // Null
+    else if (isNullable<T>() && data == null) {
+      return "null";
     } else {
       return "null";
     }
@@ -72,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
@@ -83,48 +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: u32 = 0
-      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 (char === "\"".charCodeAt(0) && data.charCodeAt(i - 1) !== "/".charCodeAt(0)) instr = (instr ? 0 : 1)
-        else if (instr === 0) {
-          if (char === leftBraceCode || char === leftBracketCode) depth++
-          if (char === rightBraceCode || char === rightBracketCode) fdepth++
-        }
-        if (depth !== 0 && depth === fdepth) {
-          result.set(key, data.slice(lastPos + 1, i + 1))
-          // Reset the depth
-          depth = 0
-          fdepth = 0
-          // Set new lastPos
-          lastPos = i + 1
-        }
-        if (depth === 0) {
-          if (char === colonCode) {
-            key = data.slice(lastPos + 1, i - 1)
-            lastPos = i
-          }
-          else if (char === commaCode) {
-            if ((i - lastPos) > 0) result.set(key, data.slice(lastPos + 1, i))
-            lastPos = i + 1
-          }
-        }
-      }
-
-      if ((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;
@@ -134,25 +128,21 @@ export namespace JSON {
 
 // @ts-ignore
 @inline
-  function serializeString(data: string): string {
-  return '"' + data.replaceAll('"', '\\"') + '"';
-}
-// @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);
@@ -176,162 +166,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
-    parseNumber<valueof<T>>(data.slice(lastPos, data.length - 1).trimStart())
-  );
+    return parseBooleanArray<T>(data);
+  } else if (isArrayLike<valueof<T>>()) {
+    // @ts-ignore
+    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;
-    }
-    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;
-        }
-      }
+  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;
     }
   }
-  /*char = data.charCodeAt(lastPos)
-  // Remove preceeding whitespace
-  while (isSpace(char)) {
-    lastPos++;
-    char = data.charCodeAt(lastPos);
+  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(--len);
-  while (isSpace(char)) {
-    len--;
-    char = data.charCodeAt(len);
-  }*/
-
-  // @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()}-`)
   return result;
 }
 
-export function parseObject(data: string): void {
-  //const obj = instantiate<T>()
-  const result = new Array<string>();
-  let lastPos: u32 = 0;
-  let char: u32 = 0;
-  let i: u32 = 1;
-  let key: string = "";
-  let isKey: boolean = false;
-  for (; i < u32(data.length - 1); i++) {
-    char = data.charCodeAt(i);
-    if (isKey == false) {
-      if (char == colonCode) {
-        key = data.slice(lastPos + 2, i - 1);
-        //console.log(`Found Key: ${key}`);
-        result.push(key);
-        lastPos = ++i;
-        isKey = true;
+// @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;
       }
-    } else {
-      if (char == commaCode) {
-        const val = data.slice(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)));
+      }
+    }
+  }
+  return result;
+}
+
+// @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;
-        isKey = false;
-        //console.log(`Found Val: ${val}`)
-        result.push(val);
+      }
+      // 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)));
       }
     }
   }
-  result.push(data.slice(lastPos, data.length - 1));
-  //console.log(stringify(result))
-  //return obj
+  return result;
 }
 
-class Nullable { }
+class Nullable {}