emusks 2.3.7 → 2.3.8

package/src/parsers/jetfuel-messages.js

@@ -0,0 +1,121 @@
+export function decodeJetfuelMessages(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const strings = [];
+  const messages = [];
+  let offset = 0;
+  let end = bytes.length;
+  const take = (length) => {
+    if (offset + length > end) throw new Error("truncated jetfuel message");
+    const start = offset;
+    offset += length;
+    return start;
+  };
+  const u8 = () => view.getUint8(take(1));
+  const uint = () => {
+    let value = 0;
+    for (let shift = 0; shift < 49; shift += 7) {
+      const byte = u8();
+      value += (byte & 127) * 2 ** shift;
+      if (!(byte & 128)) return value;
+    }
+    throw new Error("invalid jetfuel integer");
+  };
+  const i16 = () => view.getInt16(take(2), true);
+  const i32 = () => view.getInt32(take(4), true);
+  const i64 = () => view.getBigInt64(take(8), true);
+  const f64 = () => view.getFloat64(take(8), true);
+  const bool = () => Boolean(u8());
+  const str = () => {
+    const length = uint();
+    const start = take(length);
+    const value = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, start + length));
+    strings.push(value);
+    return value;
+  };
+  const tuple = (...readers) => () => readers.map((read) => read());
+  const list = (read) => () => {
+    const count = uint();
+    if (count > end - offset) throw new Error("invalid jetfuel list length");
+    return Array.from({ length: count }, read);
+  };
+  const dict = (key, value) => () => new Map(list(tuple(key, value))());
+  const optional = (read) => () => bool() ? read() : null;
+  const record = (fields) => () => Object.fromEntries(Object.entries(fields).map(([key, read]) => [key, read()]));
+  const constant = (value) => () => value;
+  const variant = (schema) => {
+    let readers;
+    const read = () => {
+      const tag = u8();
+      if (!readers[tag]) throw new Error(`unknown jetfuel tag ${tag}`);
+      return [tag, readers[tag]()];
+    };
+    readers = typeof schema === "function" ? schema(read) : schema;
+    return read;
+  };
+  const element = record({ type: i16, props: dict(i16, uint), children: list(uint), id: optional(i64), extend: optional(uint) });
+  const ref = variant({
+    0: record({ id: i64 }), 4: record({ id: i64, root: uint }),
+    1: record({ key: i16, root: uint }),
+    ...Object.fromEntries([2, 3, 7, 8].map((tag) => [tag, record({ key: str, root: uint })])),
+    ...Object.fromEntries([5, 6, 9, 10, 11].map((tag) => [tag, record({ root: uint })])),
+  });
+  const mutation = variant({
+    0: ref, 1: tuple(ref, uint), 2: tuple(ref, i16), 3: tuple(ref, str),
+    4: tuple(ref, uint, optional(i16)), 5: tuple(ref, uint),
+    6: tuple(ref, optional(tuple(uint, uint))), 7: tuple(ref, uint), 8: tuple(ref, uint),
+  });
+  const navigation = variant({
+    0: record({ url: uint, preview: optional(uint), replace: bool }),
+    9: record({ url: uint, preview: optional(uint), replace: bool }),
+    1: record({ url: uint, body: optional(uint), preview: optional(uint), replace: bool }),
+    8: record({ url: uint }), 7: record({ id: uint }),
+    ...Object.fromEntries([2, 3, 4, 5, 6].map((tag) => [tag, constant(null)])),
+  });
+  const action = variant((self) => ({
+    0: mutation, 1: record({ ref: uint, action: self, cancel: optional(self) }),
+    2: list(self), 3: record({ url: uint, body: uint, complete: optional(self), error: optional(self), optimistic: optional(self) }),
+    4: record({ action: self, intensity: i16 }), 5: record({ ref: uint, type: u8 }),
+    21: record({ ref: uint, duration: i16, animation: bool }),
+    19: record({ ref: uint, type: u8, allowsRotation: bool }),
+    20: record({ ref: uint, overlay: uint, mode: str }), 6: navigation,
+    7: record({ type: u8, id: optional(i64) }), 8: str,
+    9: record({ urls: list(str), priority: u8 }), 10: record({ action: str, ref: uint }),
+    11: record({ type: u8, ref: uint }), 12: record({ action: self, delaySeconds: i16 }),
+    13: record({ data: str, secret: str, knownDeviceToken: str }),
+    14: record({ text: str, dismissText: optional(str) }), 15: record({ ref: uint, to: uint }),
+    16: record({ ref: uint, fields: list(str) }), 17: record({ ref: uint, using: uint }),
+    18: record({ ref: uint, field: str }),
+  }));
+  const condition = variant((self) => ({
+    0: record({ ref }), 15: record({ ref }),
+    ...Object.fromEntries([1, 2, 5, 6, 7, 8].map((tag) => [tag, record({ ref, value: uint })])),
+    3: record({ ref, value: list(uint) }), 4: record({ ref, value: list(uint) }),
+    ...Object.fromEntries([9, 10, 11].map((tag) => [tag, record({ ref, value: str })])),
+    12: tuple(self, self), 13: tuple(self, self), 14: self,
+  }));
+  const matrix = list(list(i32));
+  const property = variant({
+    0: str, 1: i32, 3: matrix, 25: list(tuple(matrix, condition)),
+    4: i64, 5: f64, 6: bool, 7: uint, 8: list(uint), 10: uint, 11: str,
+    12: list(tuple(u8, str, optional(str))), 14: i64, 15: uint,
+    16: dict(i16, uint), 17: dict(str, str),
+    18: record({ ref, prop_ref: uint, is_default: bool }), 31: record({ ref }),
+    19: action, 21: list(uint), 22: condition, 24: list(uint),
+    26: list(str), 27: list(i32), 28: list(f64), 29: list(bool),
+    30: tuple(str, dict(str, str), dict(str, str), str, u8), 13: constant(undefined),
+  });
+  const message = variant({
+    0: record({ els: list(element), props: list(property), ts: i32 }),
+    1: record({ ref: uint, t: optional(i32) }), 2: action,
+  });
+  while (offset < bytes.length) {
+    end = bytes.length;
+    const length = view.getUint32(take(4), true);
+    end = offset + length;
+    if (end > bytes.length) throw new Error("truncated jetfuel frame");
+    messages.push(message());
+    if (offset !== end) throw new Error("unexpected jetfuel frame data");
+  }
+  return { messages, strings };
+}