json-as 0.8.6 → 0.8.8

package/assembly/deserialize/string.ts

@@ -0,0 +1,88 @@
+import {
+    bCode,
+    backSlashCode,
+    backspaceCode,
+    carriageReturnCode,
+    fCode,
+    formFeedCode,
+    forwardSlashCode,
+    nCode,
+    newLineCode,
+    quoteCode,
+    rCode,
+    tCode,
+    tabCode,
+    uCode
+} from "../src/chars";
+import { Sink } from "../src/sink";
+import { unsafeCharCodeAt } from "../src/util";
+
+// @ts-ignore: Decorator
+@inline export function deserializeString(data: string, start: i32 = 0, end: i32 = 0): string {
+    end = end || data.length - 1;
+    let result = Sink.withCapacity(end - start - 1);
+    let last = start + 1;
+    for (let i = last; i < end; i++) {
+        if (unsafeCharCodeAt(data, i) !== backSlashCode) {
+            continue;
+        }
+        const char = unsafeCharCodeAt(data, ++i);
+        result.write(data, last, i - 1);
+        switch (char) {
+            case quoteCode: {
+                result.writeCodePoint(quoteCode);
+                last = i + 1;
+                break;
+            }
+            case backSlashCode: {
+                result.writeCodePoint(backSlashCode);
+                last = i + 1;
+                break;
+            }
+            case forwardSlashCode: {
+                result.writeCodePoint(forwardSlashCode);
+                last = i + 1;
+                break;
+            }
+            case bCode: {
+                result.writeCodePoint(backspaceCode);
+                last = i + 1;
+                break;
+            }
+            case fCode: {
+                result.writeCodePoint(formFeedCode);
+                last = i + 1;
+                break;
+            }
+            case nCode: {
+                result.writeCodePoint(newLineCode);
+                last = i + 1;
+                break;
+            }
+            case rCode: {
+                result.writeCodePoint(carriageReturnCode);
+                last = i + 1;
+                break;
+            }
+            case tCode: {
+                result.writeCodePoint(tabCode);
+                last = i + 1;
+                break;
+            }
+            case uCode: {
+                const code = u16.parse(data.slice(i + 1, i + 5), 16);
+                result.writeCodePoint(code);
+                i += 4;
+                last = i + 1;
+                break;
+            }
+            default: {
+                throw new Error(`JSON: Cannot parse "${data}" as string. Invalid escape sequence: \\${data.charAt(i)}`);
+            }
+        }
+    }
+    if (end > last) {
+        result.write(data, last, end);
+    }
+    return result.toString()
+}

package/assembly/serialize/array.ts

@@ -0,0 +1,51 @@
+import {
+    commaCode,
+    commaWord,
+    emptyArrayWord,
+    leftBracketWord,
+    rightBracketCode,
+    rightBracketWord
+} from "../src/chars";
+import { Sink } from "../src/sink";
+import { serializeString } from "./string";
+
+// @ts-ignore
+@inline export function serializeArray<T extends any[]>(data: T): string {
+    // @ts-ignore
+    if (data.length == 0) {
+        return emptyArrayWord;
+        // @ts-ignore
+    } else if (isString<valueof<T>>()) {
+        let result = leftBracketWord;
+        // @ts-ignore
+        for (let i = 0; i < data.length - 1; i++) {
+            // @ts-ignore
+            result += serializeString(unchecked(data[i]));
+            result += commaWord;
+        }
+        // @ts-ignore
+        result += serializeString(unchecked(data[data.length - 1]));
+        result += rightBracketWord;
+        return result;
+        // @ts-ignore
+    } else if (isBoolean<valueof<T>>()) {
+        // @ts-ignore
+        return leftBracketWord + data.join(commaWord) + rightBracketWord;
+        // @ts-ignore
+    } else if (isFloat<valueof<T>>() || isInteger<valueof<T>>()) {
+        // @ts-ignore
+        return leftBracketWord + data.join(commaWord) + rightBracketWord;
+    } else {
+        let result = Sink.fromString(leftBracketWord);
+        // @ts-ignore
+        for (let i = 0; i < data.length - 1; i++) {
+            // @ts-ignore
+            result.write(__JSON_Stringify(unchecked(data[i])));
+            result.writeCodePoint(commaCode);
+        }
+        // @ts-ignore
+        result.write(__JSON_Stringify(unchecked(data[data.length - 1])));
+        result.writeCodePoint(rightBracketCode);
+        return result.toString();
+    }
+}

package/assembly/serialize/bool.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+@inline export function serializeBool(data: bool): string {
+    return data ? "true" : "false";
+}

package/assembly/serialize/box.ts

@@ -0,0 +1,10 @@
+import { nullWord } from "../src/chars";
+import { JSON } from "../src/json";
+
+// @ts-ignore
+@inline export function serializeBox<T extends Box<any>>(data: T): string {
+  if (isNullable<T>() && changetype<usize>(data) == <usize>0) {
+    return nullWord;
+  }
+  return JSON.stringify(data.unwrap());
+}

package/assembly/serialize/date.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+@inline export function serializeDate(data: Date): string {
+    return `"${data.toISOString()}"`
+}

package/assembly/serialize/float.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+@inline export function serializeFloat<T extends number>(data: T): string {
+    return data.toString();
+}

package/assembly/serialize/integer.ts

@@ -0,0 +1,5 @@
+// @ts-ignore
+@inline export function serializeInteger<T extends number>(data: T): string {
+    // I have a much faster implementation of itoa that I will port over later. Its ~4x faster
+    return data.toString();
+}

package/assembly/serialize/map.ts

@@ -0,0 +1,24 @@
+import { colonCode, commaCode, leftBraceWord, rightBraceCode } from "../src/chars";
+import { JSON } from "../src/json";
+import { Sink } from "../src/sink";
+import { serializeString } from "./string";
+
+// @ts-ignore
+@inline export function serializeMap<T extends Map<any, any>>(data: T): string {
+    let result = Sink.fromString(leftBraceWord);
+    let keys = data.keys();
+    let values = data.values();
+    const end = data.size - 1;
+    for (let i = 0; i < end; i++) {
+        result.write(serializeString(unchecked(keys[i]).toString()));
+        result.writeCodePoint(colonCode);
+        result.write(JSON.stringify(unchecked(values[i])));
+        result.writeCodePoint(commaCode);
+    }
+    result.write(serializeString(unchecked(keys[end]).toString()));
+    result.writeCodePoint(colonCode);
+    result.write(JSON.stringify(unchecked(values[end])));
+
+    result.writeCodePoint(rightBraceCode);
+    return result.toString();
+}

package/assembly/serialize/object.ts

@@ -0,0 +1,7 @@
+interface GeneratedInterface {
+    __SERIALIZE(): string;
+}
+// @ts-ignore
+@inline export function serializeObject<T extends GeneratedInterface>(data: T): string {
+    return changetype<nonnull<T>>(data).__SERIALIZE();
+}

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();
+}