diff --git a/.gitea/workflows/tests.yaml b/.gitea/workflows/tests.yaml index 1285573..0943b0b 100644 --- a/.gitea/workflows/tests.yaml +++ b/.gitea/workflows/tests.yaml @@ -13,5 +13,5 @@ jobs: - uses: actions/checkout@v3 with: submodules: recursive - - name: graphql-codegen causes no changes + - name: codegen causes no changes run: ./bin/assert-no-changes-wrapper.sh diff --git a/README.md b/README.md new file mode 100644 index 0000000..8010d10 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# rbgql diff --git a/bin/assert-no-changes.sh b/bin/assert-no-changes.sh index 2d7c473..252a644 100755 --- a/bin/assert-no-changes.sh +++ b/bin/assert-no-changes.sh @@ -4,6 +4,12 @@ git ls-files | xargs md5sum > before.txt yarn install yarn graphql-codegen prettier ./src --write +for proto in $(find ./rbproto -iname '*.proto'); do + name=$(basename "$proto" .proto) + protoc -I=./rbproto --python_out=./rbproto/python --pyi_out=./rbproto/python ./rbproto/shot.proto + yarn pbjs ./rbproto/shot.proto --ts ./rbproto/ts/shot.ts +done +prettier ./rbproto --write git ls-files | xargs md5sum > after.txt diff --git a/flake.nix b/flake.nix index 65be774..165ccbb 100644 --- a/flake.nix +++ b/flake.nix @@ -21,7 +21,7 @@ in with pkgs; { devShell = mkShell { - buildInputs = [nodejs yarn watchman alejandra nodePackages.prettier just]; + buildInputs = [nodejs yarn watchman alejandra nodePackages.prettier just protobuf]; }; }); } diff --git a/justfile b/justfile index facc4a2..f29a389 100644 --- a/justfile +++ b/justfile @@ -1,4 +1,5 @@ NIX := "LD_LIBRARY_PATH='' nix" +PROTOBUF_DIR := "$PWD/rbproto" prettier-gql: #!/usr/bin/env bash @@ -12,3 +13,27 @@ gql-codegen: gql: gql-codegen prettier-gql + +protobuf-compile-a-python name: + protoc -I={{ PROTOBUF_DIR }} --python_out={{ PROTOBUF_DIR }}/python --pyi_out={{ PROTOBUF_DIR }}/python {{ PROTOBUF_DIR }}/shot.proto + +protobuf-compile-a-js name: + #!/usr/bin/env bash + set -euxo pipefail + {{NIX}} develop --impure --command bash -c 'yarn pbjs {{ PROTOBUF_DIR }}/shot.proto --ts {{ PROTOBUF_DIR }}/ts/shot.ts && yarn prettier ./rbproto --write' + +protobuf-compile-all-js: + #!/usr/bin/env bash + for proto in $(find {{ PROTOBUF_DIR }} -iname '*.proto'); do + name=$(basename "$proto" .proto) + just protobuf-compile-a-js $name + done + +protobuf-compile-all-python: + #!/usr/bin/env bash + for proto in $(find {{ PROTOBUF_DIR }} -iname '*.proto'); do + name=$(basename "$proto" .proto) + just protobuf-compile-a-python $name + done + +protobuf-compile-everything: protobuf-compile-all-js protobuf-compile-all-python \ No newline at end of file diff --git a/package.json b/package.json index b05d0d2..70ecbe8 100644 --- a/package.json +++ b/package.json @@ -18,6 +18,7 @@ "@graphql-codegen/typescript-operations": "^4.0.1", "@graphql-codegen/typescript-react-apollo": "^4.2.0", "graphql": "^16.8.1", + "pbjs": "^0.0.14", "prettier": "^3.2.5", "prettier-plugin-organize-imports": "^3.2.4" }, diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..0ab95cc --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,16 @@ +[tool.poetry] +name = "rbgql" +version = "0.1.0" +description = "" +authors = ["Mike Kalange "] +readme = "README.md" +packages = [{include = "rbproto"}] + +[tool.poetry.dependencies] +python = ">=3.10,<3.12" +protobuf = "^4.25.3" + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/rbproto/__init__.py b/rbproto/__init__.py new file mode 100644 index 0000000..397f57e --- /dev/null +++ b/rbproto/__init__.py @@ -0,0 +1 @@ +from .python.shot_pb2 import * # noqa: F401 diff --git a/rbproto/python/shot_pb2.py b/rbproto/python/shot_pb2.py new file mode 100644 index 0000000..e6861d7 --- /dev/null +++ b/rbproto/python/shot_pb2.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: shot.proto +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\",\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\x12\r\n\x05\x63ount\x18\x03 \x01(\x05\"i\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12\x11\n\tis_static\x18\x03 \x01(\x08\x12&\n\x06points\x18\x04 \x03(\x0b\x32\x16.serialized_shot.Point\"J\n\tBallPaths\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\x05\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"^\n\x04Shot\x12\x13\n\x0bstart_frame\x18\x01 \x01(\x05\x12\x11\n\tend_frame\x18\x02 \x01(\x05\x12.\n\nball_paths\x18\x03 \x03(\x0b\x32\x1a.serialized_shot.BallPathsb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'shot_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_POINT']._serialized_start=31 + _globals['_POINT']._serialized_end=75 + _globals['_PATH']._serialized_start=77 + _globals['_PATH']._serialized_end=182 + _globals['_BALLPATHS']._serialized_start=184 + _globals['_BALLPATHS']._serialized_end=258 + _globals['_SHOT']._serialized_start=260 + _globals['_SHOT']._serialized_end=354 +# @@protoc_insertion_point(module_scope) diff --git a/rbproto/python/shot_pb2.pyi b/rbproto/python/shot_pb2.pyi new file mode 100644 index 0000000..71354b1 --- /dev/null +++ b/rbproto/python/shot_pb2.pyi @@ -0,0 +1,46 @@ +from google.protobuf.internal import containers as _containers +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class Point(_message.Message): + __slots__ = ["x", "y", "count"] + X_FIELD_NUMBER: _ClassVar[int] + Y_FIELD_NUMBER: _ClassVar[int] + COUNT_FIELD_NUMBER: _ClassVar[int] + x: float + y: float + count: int + def __init__(self, x: _Optional[float] = ..., y: _Optional[float] = ..., count: _Optional[int] = ...) -> None: ... + +class Path(_message.Message): + __slots__ = ["start_frame", "end_frame", "is_static", "points"] + START_FRAME_FIELD_NUMBER: _ClassVar[int] + END_FRAME_FIELD_NUMBER: _ClassVar[int] + IS_STATIC_FIELD_NUMBER: _ClassVar[int] + POINTS_FIELD_NUMBER: _ClassVar[int] + start_frame: int + end_frame: int + is_static: bool + points: _containers.RepeatedCompositeFieldContainer[Point] + def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., is_static: bool = ..., points: _Optional[_Iterable[_Union[Point, _Mapping]]] = ...) -> None: ... + +class BallPaths(_message.Message): + __slots__ = ["ball_identifier", "paths"] + BALL_IDENTIFIER_FIELD_NUMBER: _ClassVar[int] + PATHS_FIELD_NUMBER: _ClassVar[int] + ball_identifier: int + paths: _containers.RepeatedCompositeFieldContainer[Path] + def __init__(self, ball_identifier: _Optional[int] = ..., paths: _Optional[_Iterable[_Union[Path, _Mapping]]] = ...) -> None: ... + +class Shot(_message.Message): + __slots__ = ["start_frame", "end_frame", "ball_paths"] + START_FRAME_FIELD_NUMBER: _ClassVar[int] + END_FRAME_FIELD_NUMBER: _ClassVar[int] + BALL_PATHS_FIELD_NUMBER: _ClassVar[int] + start_frame: int + end_frame: int + ball_paths: _containers.RepeatedCompositeFieldContainer[BallPaths] + def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., ball_paths: _Optional[_Iterable[_Union[BallPaths, _Mapping]]] = ...) -> None: ... diff --git a/rbproto/shot.proto b/rbproto/shot.proto new file mode 100644 index 0000000..49933e3 --- /dev/null +++ b/rbproto/shot.proto @@ -0,0 +1,27 @@ +syntax = "proto3"; + +package serialized_shot; + +message Point { + float x = 1; + float y = 2; + int32 count = 3; +} + +message Path { + int32 start_frame = 1; + int32 end_frame = 2; + bool is_static = 3; + repeated Point points = 4; +} + +message BallPaths { + int32 ball_identifier = 1; + repeated Path paths = 2; +} + +message Shot { + int32 start_frame = 1; + int32 end_frame = 2; + repeated BallPaths ball_paths = 3; +} \ No newline at end of file diff --git a/rbproto/ts/shot.ts b/rbproto/ts/shot.ts new file mode 100644 index 0000000..fcb9b2a --- /dev/null +++ b/rbproto/ts/shot.ts @@ -0,0 +1,879 @@ +export interface Point { + x?: number; + y?: number; + count?: number; +} + +export function encodePoint(message: Point): Uint8Array { + let bb = popByteBuffer(); + _encodePoint(message, bb); + return toUint8Array(bb); +} + +function _encodePoint(message: Point, bb: ByteBuffer): void { + // optional float x = 1; + let $x = message.x; + if ($x !== undefined) { + writeVarint32(bb, 13); + writeFloat(bb, $x); + } + + // optional float y = 2; + let $y = message.y; + if ($y !== undefined) { + writeVarint32(bb, 21); + writeFloat(bb, $y); + } + + // optional int32 count = 3; + let $count = message.count; + if ($count !== undefined) { + writeVarint32(bb, 24); + writeVarint64(bb, intToLong($count)); + } +} + +export function decodePoint(binary: Uint8Array): Point { + return _decodePoint(wrapByteBuffer(binary)); +} + +function _decodePoint(bb: ByteBuffer): Point { + let message: Point = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional float x = 1; + case 1: { + message.x = readFloat(bb); + break; + } + + // optional float y = 2; + case 2: { + message.y = readFloat(bb); + break; + } + + // optional int32 count = 3; + case 3: { + message.count = readVarint32(bb); + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface Path { + start_frame?: number; + end_frame?: number; + is_static?: boolean; + points?: Point[]; +} + +export function encodePath(message: Path): Uint8Array { + let bb = popByteBuffer(); + _encodePath(message, bb); + return toUint8Array(bb); +} + +function _encodePath(message: Path, bb: ByteBuffer): void { + // optional int32 start_frame = 1; + let $start_frame = message.start_frame; + if ($start_frame !== undefined) { + writeVarint32(bb, 8); + writeVarint64(bb, intToLong($start_frame)); + } + + // optional int32 end_frame = 2; + let $end_frame = message.end_frame; + if ($end_frame !== undefined) { + writeVarint32(bb, 16); + writeVarint64(bb, intToLong($end_frame)); + } + + // optional bool is_static = 3; + let $is_static = message.is_static; + if ($is_static !== undefined) { + writeVarint32(bb, 24); + writeByte(bb, $is_static ? 1 : 0); + } + + // repeated Point points = 4; + let array$points = message.points; + if (array$points !== undefined) { + for (let value of array$points) { + writeVarint32(bb, 34); + let nested = popByteBuffer(); + _encodePoint(value, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + } +} + +export function decodePath(binary: Uint8Array): Path { + return _decodePath(wrapByteBuffer(binary)); +} + +function _decodePath(bb: ByteBuffer): Path { + let message: Path = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional int32 start_frame = 1; + case 1: { + message.start_frame = readVarint32(bb); + break; + } + + // optional int32 end_frame = 2; + case 2: { + message.end_frame = readVarint32(bb); + break; + } + + // optional bool is_static = 3; + case 3: { + message.is_static = !!readByte(bb); + break; + } + + // repeated Point points = 4; + case 4: { + let limit = pushTemporaryLength(bb); + let values = message.points || (message.points = []); + values.push(_decodePoint(bb)); + bb.limit = limit; + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface BallPaths { + ball_identifier?: number; + paths?: Path[]; +} + +export function encodeBallPaths(message: BallPaths): Uint8Array { + let bb = popByteBuffer(); + _encodeBallPaths(message, bb); + return toUint8Array(bb); +} + +function _encodeBallPaths(message: BallPaths, bb: ByteBuffer): void { + // optional int32 ball_identifier = 1; + let $ball_identifier = message.ball_identifier; + if ($ball_identifier !== undefined) { + writeVarint32(bb, 8); + writeVarint64(bb, intToLong($ball_identifier)); + } + + // repeated Path paths = 2; + let array$paths = message.paths; + if (array$paths !== undefined) { + for (let value of array$paths) { + writeVarint32(bb, 18); + let nested = popByteBuffer(); + _encodePath(value, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + } +} + +export function decodeBallPaths(binary: Uint8Array): BallPaths { + return _decodeBallPaths(wrapByteBuffer(binary)); +} + +function _decodeBallPaths(bb: ByteBuffer): BallPaths { + let message: BallPaths = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional int32 ball_identifier = 1; + case 1: { + message.ball_identifier = readVarint32(bb); + break; + } + + // repeated Path paths = 2; + case 2: { + let limit = pushTemporaryLength(bb); + let values = message.paths || (message.paths = []); + values.push(_decodePath(bb)); + bb.limit = limit; + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface Shot { + start_frame?: number; + end_frame?: number; + ball_paths?: BallPaths[]; +} + +export function encodeShot(message: Shot): Uint8Array { + let bb = popByteBuffer(); + _encodeShot(message, bb); + return toUint8Array(bb); +} + +function _encodeShot(message: Shot, bb: ByteBuffer): void { + // optional int32 start_frame = 1; + let $start_frame = message.start_frame; + if ($start_frame !== undefined) { + writeVarint32(bb, 8); + writeVarint64(bb, intToLong($start_frame)); + } + + // optional int32 end_frame = 2; + let $end_frame = message.end_frame; + if ($end_frame !== undefined) { + writeVarint32(bb, 16); + writeVarint64(bb, intToLong($end_frame)); + } + + // repeated BallPaths ball_paths = 3; + let array$ball_paths = message.ball_paths; + if (array$ball_paths !== undefined) { + for (let value of array$ball_paths) { + writeVarint32(bb, 26); + let nested = popByteBuffer(); + _encodeBallPaths(value, nested); + writeVarint32(bb, nested.limit); + writeByteBuffer(bb, nested); + pushByteBuffer(nested); + } + } +} + +export function decodeShot(binary: Uint8Array): Shot { + return _decodeShot(wrapByteBuffer(binary)); +} + +function _decodeShot(bb: ByteBuffer): Shot { + let message: Shot = {} as any; + + end_of_message: while (!isAtEnd(bb)) { + let tag = readVarint32(bb); + + switch (tag >>> 3) { + case 0: + break end_of_message; + + // optional int32 start_frame = 1; + case 1: { + message.start_frame = readVarint32(bb); + break; + } + + // optional int32 end_frame = 2; + case 2: { + message.end_frame = readVarint32(bb); + break; + } + + // repeated BallPaths ball_paths = 3; + case 3: { + let limit = pushTemporaryLength(bb); + let values = message.ball_paths || (message.ball_paths = []); + values.push(_decodeBallPaths(bb)); + bb.limit = limit; + break; + } + + default: + skipUnknownField(bb, tag & 7); + } + } + + return message; +} + +export interface Long { + low: number; + high: number; + unsigned: boolean; +} + +interface ByteBuffer { + bytes: Uint8Array; + offset: number; + limit: number; +} + +function pushTemporaryLength(bb: ByteBuffer): number { + let length = readVarint32(bb); + let limit = bb.limit; + bb.limit = bb.offset + length; + return limit; +} + +function skipUnknownField(bb: ByteBuffer, type: number): void { + switch (type) { + case 0: + while (readByte(bb) & 0x80) {} + break; + case 2: + skip(bb, readVarint32(bb)); + break; + case 5: + skip(bb, 4); + break; + case 1: + skip(bb, 8); + break; + default: + throw new Error("Unimplemented type: " + type); + } +} + +function stringToLong(value: string): Long { + return { + low: value.charCodeAt(0) | (value.charCodeAt(1) << 16), + high: value.charCodeAt(2) | (value.charCodeAt(3) << 16), + unsigned: false, + }; +} + +function longToString(value: Long): string { + let low = value.low; + let high = value.high; + return String.fromCharCode( + low & 0xffff, + low >>> 16, + high & 0xffff, + high >>> 16, + ); +} + +// The code below was modified from https://github.com/protobufjs/bytebuffer.js +// which is under the Apache License 2.0. + +let f32 = new Float32Array(1); +let f32_u8 = new Uint8Array(f32.buffer); + +let f64 = new Float64Array(1); +let f64_u8 = new Uint8Array(f64.buffer); + +function intToLong(value: number): Long { + value |= 0; + return { + low: value, + high: value >> 31, + unsigned: value >= 0, + }; +} + +let bbStack: ByteBuffer[] = []; + +function popByteBuffer(): ByteBuffer { + const bb = bbStack.pop(); + if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 }; + bb.offset = bb.limit = 0; + return bb; +} + +function pushByteBuffer(bb: ByteBuffer): void { + bbStack.push(bb); +} + +function wrapByteBuffer(bytes: Uint8Array): ByteBuffer { + return { bytes, offset: 0, limit: bytes.length }; +} + +function toUint8Array(bb: ByteBuffer): Uint8Array { + let bytes = bb.bytes; + let limit = bb.limit; + return bytes.length === limit ? bytes : bytes.subarray(0, limit); +} + +function skip(bb: ByteBuffer, offset: number): void { + if (bb.offset + offset > bb.limit) { + throw new Error("Skip past limit"); + } + bb.offset += offset; +} + +function isAtEnd(bb: ByteBuffer): boolean { + return bb.offset >= bb.limit; +} + +function grow(bb: ByteBuffer, count: number): number { + let bytes = bb.bytes; + let offset = bb.offset; + let limit = bb.limit; + let finalOffset = offset + count; + if (finalOffset > bytes.length) { + let newBytes = new Uint8Array(finalOffset * 2); + newBytes.set(bytes); + bb.bytes = newBytes; + } + bb.offset = finalOffset; + if (finalOffset > limit) { + bb.limit = finalOffset; + } + return offset; +} + +function advance(bb: ByteBuffer, count: number): number { + let offset = bb.offset; + if (offset + count > bb.limit) { + throw new Error("Read past limit"); + } + bb.offset += count; + return offset; +} + +function readBytes(bb: ByteBuffer, count: number): Uint8Array { + let offset = advance(bb, count); + return bb.bytes.subarray(offset, offset + count); +} + +function writeBytes(bb: ByteBuffer, buffer: Uint8Array): void { + let offset = grow(bb, buffer.length); + bb.bytes.set(buffer, offset); +} + +function readString(bb: ByteBuffer, count: number): string { + // Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8 + let offset = advance(bb, count); + let fromCharCode = String.fromCharCode; + let bytes = bb.bytes; + let invalid = "\uFFFD"; + let text = ""; + + for (let i = 0; i < count; i++) { + let c1 = bytes[i + offset], + c2: number, + c3: number, + c4: number, + c: number; + + // 1 byte + if ((c1 & 0x80) === 0) { + text += fromCharCode(c1); + } + + // 2 bytes + else if ((c1 & 0xe0) === 0xc0) { + if (i + 1 >= count) text += invalid; + else { + c2 = bytes[i + offset + 1]; + if ((c2 & 0xc0) !== 0x80) text += invalid; + else { + c = ((c1 & 0x1f) << 6) | (c2 & 0x3f); + if (c < 0x80) text += invalid; + else { + text += fromCharCode(c); + i++; + } + } + } + } + + // 3 bytes + else if ((c1 & 0xf0) == 0xe0) { + if (i + 2 >= count) text += invalid; + else { + c2 = bytes[i + offset + 1]; + c3 = bytes[i + offset + 2]; + if (((c2 | (c3 << 8)) & 0xc0c0) !== 0x8080) text += invalid; + else { + c = ((c1 & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f); + if (c < 0x0800 || (c >= 0xd800 && c <= 0xdfff)) text += invalid; + else { + text += fromCharCode(c); + i += 2; + } + } + } + } + + // 4 bytes + else if ((c1 & 0xf8) == 0xf0) { + if (i + 3 >= count) text += invalid; + else { + c2 = bytes[i + offset + 1]; + c3 = bytes[i + offset + 2]; + c4 = bytes[i + offset + 3]; + if (((c2 | (c3 << 8) | (c4 << 16)) & 0xc0c0c0) !== 0x808080) + text += invalid; + else { + c = + ((c1 & 0x07) << 0x12) | + ((c2 & 0x3f) << 0x0c) | + ((c3 & 0x3f) << 0x06) | + (c4 & 0x3f); + if (c < 0x10000 || c > 0x10ffff) text += invalid; + else { + c -= 0x10000; + text += fromCharCode((c >> 10) + 0xd800, (c & 0x3ff) + 0xdc00); + i += 3; + } + } + } + } else text += invalid; + } + + return text; +} + +function writeString(bb: ByteBuffer, text: string): void { + // Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8 + let n = text.length; + let byteCount = 0; + + // Write the byte count first + for (let i = 0; i < n; i++) { + let c = text.charCodeAt(i); + if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) { + c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00; + } + byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; + } + writeVarint32(bb, byteCount); + + let offset = grow(bb, byteCount); + let bytes = bb.bytes; + + // Then write the bytes + for (let i = 0; i < n; i++) { + let c = text.charCodeAt(i); + if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) { + c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00; + } + if (c < 0x80) { + bytes[offset++] = c; + } else { + if (c < 0x800) { + bytes[offset++] = ((c >> 6) & 0x1f) | 0xc0; + } else { + if (c < 0x10000) { + bytes[offset++] = ((c >> 12) & 0x0f) | 0xe0; + } else { + bytes[offset++] = ((c >> 18) & 0x07) | 0xf0; + bytes[offset++] = ((c >> 12) & 0x3f) | 0x80; + } + bytes[offset++] = ((c >> 6) & 0x3f) | 0x80; + } + bytes[offset++] = (c & 0x3f) | 0x80; + } + } +} + +function writeByteBuffer(bb: ByteBuffer, buffer: ByteBuffer): void { + let offset = grow(bb, buffer.limit); + let from = bb.bytes; + let to = buffer.bytes; + + // This for loop is much faster than subarray+set on V8 + for (let i = 0, n = buffer.limit; i < n; i++) { + from[i + offset] = to[i]; + } +} + +function readByte(bb: ByteBuffer): number { + return bb.bytes[advance(bb, 1)]; +} + +function writeByte(bb: ByteBuffer, value: number): void { + let offset = grow(bb, 1); + bb.bytes[offset] = value; +} + +function readFloat(bb: ByteBuffer): number { + let offset = advance(bb, 4); + let bytes = bb.bytes; + + // Manual copying is much faster than subarray+set in V8 + f32_u8[0] = bytes[offset++]; + f32_u8[1] = bytes[offset++]; + f32_u8[2] = bytes[offset++]; + f32_u8[3] = bytes[offset++]; + return f32[0]; +} + +function writeFloat(bb: ByteBuffer, value: number): void { + let offset = grow(bb, 4); + let bytes = bb.bytes; + f32[0] = value; + + // Manual copying is much faster than subarray+set in V8 + bytes[offset++] = f32_u8[0]; + bytes[offset++] = f32_u8[1]; + bytes[offset++] = f32_u8[2]; + bytes[offset++] = f32_u8[3]; +} + +function readDouble(bb: ByteBuffer): number { + let offset = advance(bb, 8); + let bytes = bb.bytes; + + // Manual copying is much faster than subarray+set in V8 + f64_u8[0] = bytes[offset++]; + f64_u8[1] = bytes[offset++]; + f64_u8[2] = bytes[offset++]; + f64_u8[3] = bytes[offset++]; + f64_u8[4] = bytes[offset++]; + f64_u8[5] = bytes[offset++]; + f64_u8[6] = bytes[offset++]; + f64_u8[7] = bytes[offset++]; + return f64[0]; +} + +function writeDouble(bb: ByteBuffer, value: number): void { + let offset = grow(bb, 8); + let bytes = bb.bytes; + f64[0] = value; + + // Manual copying is much faster than subarray+set in V8 + bytes[offset++] = f64_u8[0]; + bytes[offset++] = f64_u8[1]; + bytes[offset++] = f64_u8[2]; + bytes[offset++] = f64_u8[3]; + bytes[offset++] = f64_u8[4]; + bytes[offset++] = f64_u8[5]; + bytes[offset++] = f64_u8[6]; + bytes[offset++] = f64_u8[7]; +} + +function readInt32(bb: ByteBuffer): number { + let offset = advance(bb, 4); + let bytes = bb.bytes; + return ( + bytes[offset] | + (bytes[offset + 1] << 8) | + (bytes[offset + 2] << 16) | + (bytes[offset + 3] << 24) + ); +} + +function writeInt32(bb: ByteBuffer, value: number): void { + let offset = grow(bb, 4); + let bytes = bb.bytes; + bytes[offset] = value; + bytes[offset + 1] = value >> 8; + bytes[offset + 2] = value >> 16; + bytes[offset + 3] = value >> 24; +} + +function readInt64(bb: ByteBuffer, unsigned: boolean): Long { + return { + low: readInt32(bb), + high: readInt32(bb), + unsigned, + }; +} + +function writeInt64(bb: ByteBuffer, value: Long): void { + writeInt32(bb, value.low); + writeInt32(bb, value.high); +} + +function readVarint32(bb: ByteBuffer): number { + let c = 0; + let value = 0; + let b: number; + do { + b = readByte(bb); + if (c < 32) value |= (b & 0x7f) << c; + c += 7; + } while (b & 0x80); + return value; +} + +function writeVarint32(bb: ByteBuffer, value: number): void { + value >>>= 0; + while (value >= 0x80) { + writeByte(bb, (value & 0x7f) | 0x80); + value >>>= 7; + } + writeByte(bb, value); +} + +function readVarint64(bb: ByteBuffer, unsigned: boolean): Long { + let part0 = 0; + let part1 = 0; + let part2 = 0; + let b: number; + + b = readByte(bb); + part0 = b & 0x7f; + if (b & 0x80) { + b = readByte(bb); + part0 |= (b & 0x7f) << 7; + if (b & 0x80) { + b = readByte(bb); + part0 |= (b & 0x7f) << 14; + if (b & 0x80) { + b = readByte(bb); + part0 |= (b & 0x7f) << 21; + if (b & 0x80) { + b = readByte(bb); + part1 = b & 0x7f; + if (b & 0x80) { + b = readByte(bb); + part1 |= (b & 0x7f) << 7; + if (b & 0x80) { + b = readByte(bb); + part1 |= (b & 0x7f) << 14; + if (b & 0x80) { + b = readByte(bb); + part1 |= (b & 0x7f) << 21; + if (b & 0x80) { + b = readByte(bb); + part2 = b & 0x7f; + if (b & 0x80) { + b = readByte(bb); + part2 |= (b & 0x7f) << 7; + } + } + } + } + } + } + } + } + } + + return { + low: part0 | (part1 << 28), + high: (part1 >>> 4) | (part2 << 24), + unsigned, + }; +} + +function writeVarint64(bb: ByteBuffer, value: Long): void { + let part0 = value.low >>> 0; + let part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0; + let part2 = value.high >>> 24; + + // ref: src/google/protobuf/io/coded_stream.cc + let size = + part2 === 0 + ? part1 === 0 + ? part0 < 1 << 14 + ? part0 < 1 << 7 + ? 1 + : 2 + : part0 < 1 << 21 + ? 3 + : 4 + : part1 < 1 << 14 + ? part1 < 1 << 7 + ? 5 + : 6 + : part1 < 1 << 21 + ? 7 + : 8 + : part2 < 1 << 7 + ? 9 + : 10; + + let offset = grow(bb, size); + let bytes = bb.bytes; + + switch (size) { + case 10: + bytes[offset + 9] = (part2 >>> 7) & 0x01; + case 9: + bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7f; + case 8: + bytes[offset + 7] = + size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7f; + case 7: + bytes[offset + 6] = + size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7f; + case 6: + bytes[offset + 5] = + size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7f; + case 5: + bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7f; + case 4: + bytes[offset + 3] = + size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7f; + case 3: + bytes[offset + 2] = + size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7f; + case 2: + bytes[offset + 1] = + size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7f; + case 1: + bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7f; + } +} + +function readVarint32ZigZag(bb: ByteBuffer): number { + let value = readVarint32(bb); + + // ref: src/google/protobuf/wire_format_lite.h + return (value >>> 1) ^ -(value & 1); +} + +function writeVarint32ZigZag(bb: ByteBuffer, value: number): void { + // ref: src/google/protobuf/wire_format_lite.h + writeVarint32(bb, (value << 1) ^ (value >> 31)); +} + +function readVarint64ZigZag(bb: ByteBuffer): Long { + let value = readVarint64(bb, /* unsigned */ false); + let low = value.low; + let high = value.high; + let flip = -(low & 1); + + // ref: src/google/protobuf/wire_format_lite.h + return { + low: ((low >>> 1) | (high << 31)) ^ flip, + high: (high >>> 1) ^ flip, + unsigned: false, + }; +} + +function writeVarint64ZigZag(bb: ByteBuffer, value: Long): void { + let low = value.low; + let high = value.high; + let flip = high >> 31; + + // ref: src/google/protobuf/wire_format_lite.h + writeVarint64(bb, { + low: (low << 1) ^ flip, + high: ((high << 1) | (low >>> 31)) ^ flip, + unsigned: false, + }); +} diff --git a/src/index.tsx b/src/index.tsx index 1730f45..b10591c 100644 --- a/src/index.tsx +++ b/src/index.tsx @@ -329,6 +329,11 @@ export type RangeFilter = { lessThan?: InputMaybe; }; +export type SerializedShotPathsGql = { + __typename?: "SerializedShotPathsGQL"; + b64EncodedBuffer?: Maybe; +}; + export enum ShotDirectionEnum { Left = "LEFT", Right = "RIGHT", @@ -343,6 +348,7 @@ export type ShotGql = { endFrame: Scalars["Int"]["output"]; id: Scalars["Int"]["output"]; pocketingIntentionFeatures?: Maybe; + serializedShotPaths?: Maybe; startFrame: Scalars["Int"]["output"]; updatedAt?: Maybe; user?: Maybe; diff --git a/src/schema.gql b/src/schema.gql index a01cc6b..b0735b1 100644 --- a/src/schema.gql +++ b/src/schema.gql @@ -144,6 +144,7 @@ type ShotGQL { cueObjectFeatures: CueObjectFeaturesGQL pocketingIntentionFeatures: PocketingIntentionFeaturesGQL bankFeatures: BankFeaturesGQL + serializedShotPaths: SerializedShotPathsGQL user: UserGQL } @@ -177,6 +178,10 @@ enum WallTypeEnum { SHORT } +type SerializedShotPathsGQL { + b64EncodedBuffer: String +} + type UserGQL { id: Int! firebaseUid: String! diff --git a/yarn.lock b/yarn.lock index c27b204..d2394df 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1553,6 +1553,11 @@ colorette@^2.0.16: resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a" integrity sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w== +commander@4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/commander/-/commander-4.0.1.tgz#b67622721785993182e807f4883633e6401ba53c" + integrity sha512-IPF4ouhCP+qdlcmCedhxX4xiGBPyigb8v5NeUp+0LyhwLgxMqyp3S0vl7TAPfS/hiP7FC3caI/PB9lTmP8r1NA== + common-tags@1.8.2: version "1.8.2" resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6" @@ -2538,6 +2543,14 @@ path-type@^4.0.0: resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b" integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== +pbjs@^0.0.14: + version "0.0.14" + resolved "https://registry.yarnpkg.com/pbjs/-/pbjs-0.0.14.tgz#5ab3d4a5f06a9ab78dd320c63f72877120d4c48d" + integrity sha512-F4aA0ojrQ37kxFPOg4yRLP/vxb76rYQwMQigmVEljYlA7hZKmjaWjP6IkRn4nA0NdIj4Xxe4iqWrrIhJy+MwWQ== + dependencies: + commander "4.0.1" + protocol-buffers-schema "3.1.0" + picocolors@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c" @@ -2574,6 +2587,11 @@ prop-types@^15.7.2: object-assign "^4.1.1" react-is "^16.13.1" +protocol-buffers-schema@3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/protocol-buffers-schema/-/protocol-buffers-schema-3.1.0.tgz#d8a819549ead3e6bd189ebe9e50e96636bbc5cc7" + integrity sha512-1g9zFjLFhGN1Dc5UVO8D2loVslp6sVxk5sJqgD66CuWUITh2gOaTLRN/pIakGFfB6e0nNF6hImrYFDurEsA1UQ== + punycode@^1.3.2: version "1.4.1" resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"