json-as 1.1.11 → 1.1.13

package/assembly/test.json.ts

@@ -0,0 +1,388 @@
+import {
+  bs
+} from "../lib/as-bs";
+import {
+  JSON
+} from ".";
+import {
+  Vec3
+} from "./types";
+@json
+class Player {
+  @alias("first name")
+  firstName!: string;
+  lastName!: string;
+  lastActive!: Array<i32>;
+  @omitif((self: this): boolean => self.age < 18)
+  age!: i32;
+  @omitnull()
+  pos!: Vec3 | null;
+  isVerified!: boolean;
+  __SERIALIZE(ptr: usize): void {
+    bs.proposeSize(160);
+    let block: usize = 0;
+    store<u16>(bs.offset, 123, 0);
+    bs.offset += 2;
+    if (!((self: this): boolean => self.age < 18)(this)) {
+      store<u64>(bs.offset, 28429415035764770, 0);
+      store<u32>(bs.offset, 3801122, 8);
+      bs.offset += 12;
+      JSON.__serialize<i32>(load<i32>(ptr, offsetof<this>("age")));
+      store<u16>(bs.offset, 44, 0);
+      bs.offset += 2;
+    }
+    if ((block = load<usize>(ptr, offsetof<this>("pos"))) !== 0) {
+      store<u64>(bs.offset, 32370099070435362, 0);
+      store<u32>(bs.offset, 3801122, 8);
+      bs.offset += 12;
+      JSON.__serialize<Vec3 | null>(load<Vec3 | null>(ptr, offsetof<this>("pos")));
+      store<u16>(bs.offset, 44, 0);
+      bs.offset += 2;
+    }
+    store<u64>(bs.offset, 32088598323265570, 0);
+    store<u64>(bs.offset, 30962384884727923, 8);
+    store<u64>(bs.offset, 9570583007002721, 16);
+    store<u16>(bs.offset, 58, 24);
+    bs.offset += 26;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("firstName")));
+    store<u64>(bs.offset, 27303536599629868, 0);
+    store<u64>(bs.offset, 27303407755985011, 8);
+    store<u64>(bs.offset, 16325694684725357, 16);
+    bs.offset += 24;
+    JSON.__serialize<string>(load<string>(ptr, offsetof<this>("lastName")));
+    store<u64>(bs.offset, 27303536599629868, 0);
+    store<u64>(bs.offset, 27866301874831475, 8);
+    store<u64>(bs.offset, 28429479460798580, 16);
+    store<u32>(bs.offset, 3801122, 24);
+    bs.offset += 28;
+    JSON.__serialize<Array<i32>>(load<Array<i32>>(ptr, offsetof<this>("lastActive")));
+    store<u64>(bs.offset, 32370073295519788, 0);
+    store<u64>(bs.offset, 29555362187509846, 8);
+    store<u64>(bs.offset, 28147931469643878, 16);
+    store<u32>(bs.offset, 3801122, 24);
+    bs.offset += 28;
+    JSON.__serialize<boolean>(load<boolean>(ptr, offsetof<this>("isVerified")));
+    store<u16>(bs.offset, 125, 0);
+    bs.offset += 2;
+  }
+  @inline
+  __INITIALIZE(): this {
+    this.firstName = "";
+    this.lastName = "";
+    this.lastActive = [];
+    return this;
+  }
+  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {
+    let keyStart: usize = 0;
+    let keyEnd: usize = 0;
+    let isKey = false;
+    let depth: i32 = 0;
+    let lastIndex: usize = 0;
+    while (srcStart < srcEnd && JSON.Util.isSpace(load<u16>(srcStart))) srcStart += 2;
+    while (srcEnd > srcStart && JSON.Util.isSpace(load<u16>(srcEnd - 2))) srcEnd -= 2;
+    if (srcStart - srcEnd == 0) throw new Error("Input string had zero length or was all whitespace");
+;
+    if (load<u16>(srcStart) != 123) throw new Error("Expected '{' at start of object at position " + (srcEnd - srcStart).toString());
+;
+    if (load<u16>(srcEnd - 2) != 125) throw new Error("Expected '}' at end of object at position " + (srcEnd - srcStart).toString());
+;
+    srcStart += 2;
+    while (srcStart < srcEnd) {
+      let code = load<u16>(srcStart);
+      while (JSON.Util.isSpace(code)) code = load<u16>(srcStart += 2);
+      if (keyStart == 0) {
+        if (code == 34 && load<u16>(srcStart - 2) !== 92) {
+          if (isKey) {
+            keyStart = lastIndex;
+            keyEnd = srcStart;
+            while (JSON.Util.isSpace((code = load<u16>((srcStart += 2))))) {}
+            if (code !== 58) throw new Error("Expected ':' after key at position " + (srcEnd - srcStart).toString());
+;
+            isKey = false;
+          } else {
+            isKey = true;
+            lastIndex = srcStart + 2;
+          }
+        }
+        srcStart += 2;
+      } else {
+        if (code == 34) {
+          lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34 && load<u16>(srcStart - 2) !== 92) {
+              switch (<u32>keyEnd - <u32>keyStart) {
+                case 20:
+                  {
+                    const codeS8 = load<u64>(keyStart, 0);
+                    const codeS16 = load<u64>(keyStart, 8);
+                    const codeS20 = load<u32>(keyStart, 16);
+                    if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("firstName"));
+                      srcStart += 4;
+                      keyStart = 0;
+                      break;
+                    } else {
+                      srcStart += 4;
+                      keyStart = 0;
+                      break;
+                    }
+                  }
+
+                case 16:
+                  {
+                    const codeS8 = load<u64>(keyStart, 0);
+                    const codeS16 = load<u64>(keyStart, 8);
+                    if (codeS8 == 32651591226032236 && codeS16 == 28429440805568590) {
+                      store<string>(changetype<usize>(out), JSON.__deserialize<string>(lastIndex, srcStart + 2), offsetof<this>("lastName"));
+                      srcStart += 4;
+                      keyStart = 0;
+                      break;
+                    } else {
+                      srcStart += 4;
+                      keyStart = 0;
+                      break;
+                    }
+                  }
+
+                default:
+                  {
+                    srcStart += 4;
+                    keyStart = 0;
+                    break;
+                  }
+
+}
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code - 48 <= 9 || code == 45) {
+          lastIndex = srcStart;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 44 || code == 125 || JSON.Util.isSpace(code)) {
+              switch (<u32>keyEnd - <u32>keyStart) {
+                case 6:
+                  {
+                    const code48 = load<u64>(keyStart) & 281474976710655;
+                    if (code48 == 433798447201) {
+                      store<i32>(changetype<usize>(out), JSON.__deserialize<i32>(lastIndex, srcStart), offsetof<this>("age"));
+                      srcStart += 2;
+                      keyStart = 0;
+                      break;
+                    } else {
+                      srcStart += 2;
+                      keyStart = 0;
+                      break;
+                    }
+                  }
+
+                default:
+                  {
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  }
+
+}
+              break;
+            }
+            srcStart += 2;
+          }
+        } else if (code == 123) {
+          lastIndex = srcStart;
+          depth++;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34) {
+              srcStart += 2;
+              while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
+            } else if (code == 125) {
+              if (--depth == 0) {
+                srcStart += 2;
+                switch (<u32>keyEnd - <u32>keyStart) {
+                  case 6:
+                    {
+                      const code48 = load<u64>(keyStart) & 281474976710655;
+                      if (code48 == 493928513648) {
+                        store<Vec3 | null>(changetype<usize>(out), JSON.__deserialize<Vec3 | null>(lastIndex, srcStart), offsetof<this>("pos"));
+                        keyStart = 0;
+                        break;
+                      } else {
+                        keyStart = 0;
+                        break;
+                      }
+                    }
+
+                  default:
+                    {
+                      keyStart = 0;
+                      break;
+                    }
+
+}
+                break;
+              }
+            } else if (code == 123) depth++;
+;
+            srcStart += 2;
+          }
+        } else if (code == 91) {
+          lastIndex = srcStart;
+          depth++;
+          srcStart += 2;
+          while (srcStart < srcEnd) {
+            const code = load<u16>(srcStart);
+            if (code == 34) {
+              srcStart += 2;
+              while (!(load<u16>(srcStart) == 34 && load<u16>(srcStart - 2) != 92)) srcStart += 2;
+            } else if (code == 93) {
+              if (--depth == 0) {
+                srcStart += 2;
+                switch (<u32>keyEnd - <u32>keyStart) {
+                  case 20:
+                    {
+                      const codeS8 = load<u64>(keyStart, 0);
+                      const codeS16 = load<u64>(keyStart, 8);
+                      const codeS20 = load<u32>(keyStart, 16);
+                      if (codeS8 == 32651591226032236 && codeS16 == 29555370777313345 && codeS20 == 6619254) {
+                        store<Array<i32>>(changetype<usize>(out), JSON.__deserialize<Array<i32>>(lastIndex, srcStart), offsetof<this>("lastActive"));
+                        keyStart = 0;
+                        break;
+                      } else {
+                        keyStart = 0;
+                        break;
+                      }
+                    }
+
+                  default:
+                    {
+                      keyStart = 0;
+                      break;
+                    }
+
+}
+                break;
+              }
+            } else if (code == 91) depth++;
+;
+            srcStart += 2;
+          }
+        } else if (code == 116) {
+          if (load<u64>(srcStart) == 28429475166421108) {
+            srcStart += 8;
+            switch (<u32>keyEnd - <u32>keyStart) {
+              case 20:
+                {
+                  const codeS8 = load<u64>(keyStart, 0);
+                  const codeS16 = load<u64>(keyStart, 8);
+                  const codeS20 = load<u32>(keyStart, 16);
+                  if (codeS8 == 28429342022500457 && codeS16 == 29555310648164466 && codeS20 == 6553701) {
+                    store<boolean>(changetype<usize>(out), true, offsetof<this>("isVerified"));
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  } else {
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  }
+                }
+
+              default:
+                {
+                  srcStart += 2;
+                  keyStart = 0;
+                }
+
+}
+          } else {
+            throw new Error("Expected to find 'true' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
+          }
+        } else if (code == 102) {
+          if (load<u64>(srcStart, 2) == 28429466576093281) {
+            srcStart += 10;
+            switch (<u32>keyEnd - <u32>keyStart) {
+              case 20:
+                {
+                  const codeS8 = load<u64>(keyStart, 0);
+                  const codeS16 = load<u64>(keyStart, 8);
+                  const codeS20 = load<u32>(keyStart, 16);
+                  if (codeS8 == 28429342022500457 && codeS16 == 29555310648164466 && codeS20 == 6553701) {
+                    store<boolean>(changetype<usize>(out), false, offsetof<this>("isVerified"));
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  } else {
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  }
+                }
+
+              default:
+                {
+                  srcStart += 2;
+                  keyStart = 0;
+                }
+
+}
+          } else {
+            throw new Error("Expected to find 'false' but found '" + JSON.Util.ptrToStr(lastIndex, srcStart) + "' instead at position " + (srcEnd - srcStart).toString());
+          }
+        } else if (code == 110) {
+          if (load<u64>(srcStart) == 30399761348886638) {
+            srcStart += 8;
+            switch (<u32>keyEnd - <u32>keyStart) {
+              case 6:
+                {
+                  const code48 = load<u64>(keyStart) & 281474976710655;
+                  if (code48 == 493928513648) {
+                    store<usize>(changetype<usize>(out), 0, offsetof<this>("pos"));
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  } else {
+                    srcStart += 2;
+                    keyStart = 0;
+                    break;
+                  }
+                }
+
+              default:
+                {
+                  srcStart += 2;
+                  keyStart = 0;
+                }
+
+}
+          }
+        } else {
+          srcStart += 2;
+          keyStart = 0;
+        }
+      }
+    }
+    return out;
+  }
+}
+const player: Player = {
+  firstName: "Jairus",
+  lastName: "Tanaka",
+  lastActive: [3, 9, 2025],
+  age: 18,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3
+  },
+  isVerified: true
+};
+const serialized = JSON.stringify(player);
+console.log("Serialized: " + serialized);
+const deserialized = JSON.parse<Player>(serialized);
+console.log("Deserialized: " + JSON.stringify(deserialized));

package/assembly/test.ts

@@ -1,182 +1,33 @@
 import { JSON } from ".";
-import { expect, it } from "./__tests__/lib";
-
-it("should parse", () => {
-  const str = `{
-  "id": "chatcmpl-BbvlnP0ESWa8OForeEjt7AkoIuh3Q",
-  "object": "chat.completion",
-  "created": 1748379903,
-  "model": "gpt-4o-mini-2024-07-18",
-  "choices": [
-    {
-      "index": 0,
-      "message": {
-        "role": "assistant",
-        "content": "Hello! How can I assist you today?",
-        "refusal": null,
-        "annotations": []
-      },
-      "logprobs": null,
-      "finish_reason": "stop"
-    }
-  ],
-  "usage": {
-    "prompt_tokens": 15,
-    "completion_tokens": 9,
-    "total_tokens": 24,
-    "prompt_tokens_details": {
-      "cached_tokens": 0,
-      "audio_tokens": 0
-    },
-    "completion_tokens_details": {
-      "reasoning_tokens": 0,
-      "audio_tokens": 0,
-      "accepted_prediction_tokens": 0,
-      "rejected_prediction_tokens": 0
-    }
-  },
-  "service_tier": "default",
-  "system_fingerprint": "fp_34a54ae93c"
-}`;
-
-  const output = JSON.parse<OpenAIChatOutput>(str);
-  expect(output.id).toBe("chatcmpl-BbvlnP0ESWa8OForeEjt7AkoIuh3Q");
-  expect(output.object).toBe("chat.completion");
-  expect(output.created.getTime()).toBe(1748379903000);
-  expect(output.model).toBe("gpt-4o-mini-2024-07-18");
-  expect(output.choices.length).toBe(1);
-
-  const choice = output.choices[0];
-  expect(choice.index).toBe(0);
-  expect(choice.message.content).toBe("Hello! How can I assist you today?");
-  // expect(choice.message.refusal).toBe("null");
-  // expect(choice.logprobs).toBe("null");
-  // expect(choice.finishReason).toBe("stop");
-
-  // expect(output.usage.promptTokens).toBe(15);
-  // expect(output.usage.completionTokens).toBe(9);
-  // expect(output.usage.totalTokens).toBe(24);
-  // expect(output.serviceTier).toBe("default");
-  // expect(output.systemFingerprint).toBe("fp_34a54ae93c");
-});
-
-@json
-class OpenAIChatOutput {
-  id!: string;
-
-  object!: string;
-
-  choices: Choice[] = [];
-
-  get created(): Date {
-    return new Date(this._created * 1000);
-  }
-
-  @alias("created")
-  private _created!: i64;
-
-  model!: string;
-
-  @alias("service_tier")
-  serviceTier: string | null = null;
-
-  @alias("system_fingerprint")
-  systemFingerprint!: string;
-
-  usage!: Usage;
-}
-
-@json
-class ToolCall {
-  id!: string;
-
-  type: string = "function";
-
-  function!: FunctionCall;
-}
-
-@json
-class FunctionCall {
-  name!: string;
-
-  arguments!: string;
-}
-
-@json
-class Usage {
-  @alias("completion_tokens")
-  completionTokens!: i32;
-
-  @alias("prompt_tokens")
-  promptTokens!: i32;
-
-  @alias("total_tokens")
-  totalTokens!: i32;
-}
+import { Vec3 } from "./types";
 
 @json
-class Choice {
-  @alias("finish_reason")
-  finishReason!: string;
-
-  index!: i32;
-
-  message: CompletionMessage = new CompletionMessage();
-
-  logprobs!: Logprobs | null;
-}
-
-@json
-class Logprobs {
-  content: LogprobsContent[] | null = null;
-}
-
-@json
-class LogprobsContent {
-  token!: string;
-
-  logprob!: f64;
-
-  bytes!: u8[] | null;
-
-  @alias("top_logprobs")
-  topLogprobs!: TopLogprobsContent[];
-}
-
-@json
-class TopLogprobsContent {
-  token!: string;
-
-  logprob!: f64;
-
-  bytes!: u8[] | null;
-}
-
-@json
-class CompletionMessage {
-  content!: string;
-
+class Player {
+  @alias("first name")
+  firstName!: string;
+  lastName!: string;
+  lastActive!: i32[];
+  @omitif((self: Player) => self.age < 18)
+  age!: i32;
   @omitnull()
-  refusal: string | null = null;
-
-  @alias("tool_calls")
-  @omitif((self: CompletionMessage) => self.toolCalls.length == 0)
-  toolCalls: ToolCall[] = [];
-
-  @omitnull()
-  audio: AudioOutput | null = null;
-}
-
-@json
-class AudioOutput {
-  id!: string;
-
-  get expiresAt(): Date {
-    return new Date(this._expiresAt * 1000);
-  }
-
-  @alias("expires_at")
-  private _expiresAt!: i64;
+  pos!: Vec3 | null;
+  isVerified!: boolean;
+}
+
+const player: Player = {
+  firstName: "Jairus",
+  lastName: "Tanaka",
+  lastActive: [3, 9, 2025],
+  age: 18,
+  pos: {
+    x: 3.4,
+    y: 1.2,
+    z: 8.3,
+  },
+  isVerified: true,
+};
 
-  transcript!: string;
-}
+const serialized = JSON.stringify(player);
+console.log("Serialized: " + serialized);
+const deserialized = JSON.parse<Player>(serialized);
+console.log("Deserialized: " + JSON.stringify(deserialized))

package/assembly/types.ts

@@ -65,6 +65,5 @@ export class Vec3 {
   z: f32 = 0.0;
 }
 
-
 @json
 export class Point { }