@fishjam-cloud/js-server-sdk
Version:
Fishjam server SDK for JavaScript
1,284 lines (1,282 loc) • 95.2 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// ../fishjam-proto/dist/index.js
var require_dist = __commonJS({
"../fishjam-proto/dist/index.js"(exports, module) {
"use strict";
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var __copyProps2 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2(from))
if (!__hasOwnProp2.call(to, key) && key !== except)
__defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
var index_exports = {};
__export(index_exports, {
ServerMessage: () => ServerMessage2,
ServerMessage_AuthRequest: () => ServerMessage_AuthRequest2,
ServerMessage_Authenticated: () => ServerMessage_Authenticated,
ServerMessage_ComponentCrashed: () => ServerMessage_ComponentCrashed,
ServerMessage_EventType: () => ServerMessage_EventType2,
ServerMessage_HlsPlayable: () => ServerMessage_HlsPlayable,
ServerMessage_HlsUploadCrashed: () => ServerMessage_HlsUploadCrashed,
ServerMessage_HlsUploaded: () => ServerMessage_HlsUploaded,
ServerMessage_MetricsReport: () => ServerMessage_MetricsReport,
ServerMessage_PeerAdded: () => ServerMessage_PeerAdded,
ServerMessage_PeerConnected: () => ServerMessage_PeerConnected,
ServerMessage_PeerCrashed: () => ServerMessage_PeerCrashed,
ServerMessage_PeerDeleted: () => ServerMessage_PeerDeleted,
ServerMessage_PeerDisconnected: () => ServerMessage_PeerDisconnected,
ServerMessage_PeerMetadataUpdated: () => ServerMessage_PeerMetadataUpdated,
ServerMessage_RoomCrashed: () => ServerMessage_RoomCrashed,
ServerMessage_RoomCreated: () => ServerMessage_RoomCreated,
ServerMessage_RoomDeleted: () => ServerMessage_RoomDeleted,
ServerMessage_SubscribeRequest: () => ServerMessage_SubscribeRequest,
ServerMessage_SubscribeResponse: () => ServerMessage_SubscribeResponse,
ServerMessage_Track: () => ServerMessage_Track,
ServerMessage_TrackAdded: () => ServerMessage_TrackAdded,
ServerMessage_TrackMetadataUpdated: () => ServerMessage_TrackMetadataUpdated,
ServerMessage_TrackRemoved: () => ServerMessage_TrackRemoved,
ServerMessage_TrackType: () => ServerMessage_TrackType,
protobufPackage: () => protobufPackage,
serverMessage_EventTypeFromJSON: () => serverMessage_EventTypeFromJSON,
serverMessage_EventTypeToJSON: () => serverMessage_EventTypeToJSON,
serverMessage_TrackTypeFromJSON: () => serverMessage_TrackTypeFromJSON,
serverMessage_TrackTypeToJSON: () => serverMessage_TrackTypeToJSON
});
module.exports = __toCommonJS(index_exports);
function varint64read() {
let lowBits = 0;
let highBits = 0;
for (let shift = 0; shift < 28; shift += 7) {
let b = this.buf[this.pos++];
lowBits |= (b & 127) << shift;
if ((b & 128) == 0) {
this.assertBounds();
return [lowBits, highBits];
}
}
let middleByte = this.buf[this.pos++];
lowBits |= (middleByte & 15) << 28;
highBits = (middleByte & 112) >> 4;
if ((middleByte & 128) == 0) {
this.assertBounds();
return [lowBits, highBits];
}
for (let shift = 3; shift <= 31; shift += 7) {
let b = this.buf[this.pos++];
highBits |= (b & 127) << shift;
if ((b & 128) == 0) {
this.assertBounds();
return [lowBits, highBits];
}
}
throw new Error("invalid varint");
}
function varint64write(lo, hi, bytes) {
for (let i = 0; i < 28; i = i + 7) {
const shift = lo >>> i;
const hasNext = !(shift >>> 7 == 0 && hi == 0);
const byte = (hasNext ? shift | 128 : shift) & 255;
bytes.push(byte);
if (!hasNext) {
return;
}
}
const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
const hasMoreBits = !(hi >> 3 == 0);
bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
if (!hasMoreBits) {
return;
}
for (let i = 3; i < 31; i = i + 7) {
const shift = hi >>> i;
const hasNext = !(shift >>> 7 == 0);
const byte = (hasNext ? shift | 128 : shift) & 255;
bytes.push(byte);
if (!hasNext) {
return;
}
}
bytes.push(hi >>> 31 & 1);
}
var TWO_PWR_32_DBL = 4294967296;
function int64FromString(dec) {
const minus = dec[0] === "-";
if (minus) {
dec = dec.slice(1);
}
const base = 1e6;
let lowBits = 0;
let highBits = 0;
function add1e6digit(begin, end) {
const digit1e6 = Number(dec.slice(begin, end));
highBits *= base;
lowBits = lowBits * base + digit1e6;
if (lowBits >= TWO_PWR_32_DBL) {
highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
lowBits = lowBits % TWO_PWR_32_DBL;
}
}
add1e6digit(-24, -18);
add1e6digit(-18, -12);
add1e6digit(-12, -6);
add1e6digit(-6);
return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
}
function int64ToString(lo, hi) {
let bits = newBits(lo, hi);
const negative = bits.hi & 2147483648;
if (negative) {
bits = negate(bits.lo, bits.hi);
}
const result = uInt64ToString(bits.lo, bits.hi);
return negative ? "-" + result : result;
}
function uInt64ToString(lo, hi) {
({ lo, hi } = toUnsigned(lo, hi));
if (hi <= 2097151) {
return String(TWO_PWR_32_DBL * hi + lo);
}
const low = lo & 16777215;
const mid = (lo >>> 24 | hi << 8) & 16777215;
const high = hi >> 16 & 65535;
let digitA = low + mid * 6777216 + high * 6710656;
let digitB = mid + high * 8147497;
let digitC = high * 2;
const base = 1e7;
if (digitA >= base) {
digitB += Math.floor(digitA / base);
digitA %= base;
}
if (digitB >= base) {
digitC += Math.floor(digitB / base);
digitB %= base;
}
return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
}
function toUnsigned(lo, hi) {
return { lo: lo >>> 0, hi: hi >>> 0 };
}
function newBits(lo, hi) {
return { lo: lo | 0, hi: hi | 0 };
}
function negate(lowBits, highBits) {
highBits = ~highBits;
if (lowBits) {
lowBits = ~lowBits + 1;
} else {
highBits += 1;
}
return newBits(lowBits, highBits);
}
var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
const partial = String(digit1e7);
return "0000000".slice(partial.length) + partial;
};
function varint32write(value, bytes) {
if (value >= 0) {
while (value > 127) {
bytes.push(value & 127 | 128);
value = value >>> 7;
}
bytes.push(value);
} else {
for (let i = 0; i < 9; i++) {
bytes.push(value & 127 | 128);
value = value >> 7;
}
bytes.push(1);
}
}
function varint32read() {
let b = this.buf[this.pos++];
let result = b & 127;
if ((b & 128) == 0) {
this.assertBounds();
return result;
}
b = this.buf[this.pos++];
result |= (b & 127) << 7;
if ((b & 128) == 0) {
this.assertBounds();
return result;
}
b = this.buf[this.pos++];
result |= (b & 127) << 14;
if ((b & 128) == 0) {
this.assertBounds();
return result;
}
b = this.buf[this.pos++];
result |= (b & 127) << 21;
if ((b & 128) == 0) {
this.assertBounds();
return result;
}
b = this.buf[this.pos++];
result |= (b & 15) << 28;
for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
b = this.buf[this.pos++];
if ((b & 128) != 0)
throw new Error("invalid varint");
this.assertBounds();
return result >>> 0;
}
var protoInt64 = /* @__PURE__ */ makeInt64Support();
function makeInt64Support() {
const dv = new DataView(new ArrayBuffer(8));
const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
if (ok) {
const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
return {
zero: BigInt(0),
supported: true,
parse(value) {
const bi = typeof value == "bigint" ? value : BigInt(value);
if (bi > MAX || bi < MIN) {
throw new Error(`invalid int64: ${value}`);
}
return bi;
},
uParse(value) {
const bi = typeof value == "bigint" ? value : BigInt(value);
if (bi > UMAX || bi < UMIN) {
throw new Error(`invalid uint64: ${value}`);
}
return bi;
},
enc(value) {
dv.setBigInt64(0, this.parse(value), true);
return {
lo: dv.getInt32(0, true),
hi: dv.getInt32(4, true)
};
},
uEnc(value) {
dv.setBigInt64(0, this.uParse(value), true);
return {
lo: dv.getInt32(0, true),
hi: dv.getInt32(4, true)
};
},
dec(lo, hi) {
dv.setInt32(0, lo, true);
dv.setInt32(4, hi, true);
return dv.getBigInt64(0, true);
},
uDec(lo, hi) {
dv.setInt32(0, lo, true);
dv.setInt32(4, hi, true);
return dv.getBigUint64(0, true);
}
};
}
return {
zero: "0",
supported: false,
parse(value) {
if (typeof value != "string") {
value = value.toString();
}
assertInt64String(value);
return value;
},
uParse(value) {
if (typeof value != "string") {
value = value.toString();
}
assertUInt64String(value);
return value;
},
enc(value) {
if (typeof value != "string") {
value = value.toString();
}
assertInt64String(value);
return int64FromString(value);
},
uEnc(value) {
if (typeof value != "string") {
value = value.toString();
}
assertUInt64String(value);
return int64FromString(value);
},
dec(lo, hi) {
return int64ToString(lo, hi);
},
uDec(lo, hi) {
return uInt64ToString(lo, hi);
}
};
}
function assertInt64String(value) {
if (!/^-?[0-9]+$/.test(value)) {
throw new Error("invalid int64: " + value);
}
}
function assertUInt64String(value) {
if (!/^[0-9]+$/.test(value)) {
throw new Error("invalid uint64: " + value);
}
}
var symbol = Symbol.for("@bufbuild/protobuf/text-encoding");
function getTextEncoding() {
if (globalThis[symbol] == void 0) {
const te = new globalThis.TextEncoder();
const td = new globalThis.TextDecoder();
globalThis[symbol] = {
encodeUtf8(text) {
return te.encode(text);
},
decodeUtf8(bytes) {
return td.decode(bytes);
},
checkUtf8(text) {
try {
encodeURIComponent(text);
return true;
} catch (e) {
return false;
}
}
};
}
return globalThis[symbol];
}
var WireType;
(function(WireType2) {
WireType2[WireType2["Varint"] = 0] = "Varint";
WireType2[WireType2["Bit64"] = 1] = "Bit64";
WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
WireType2[WireType2["Bit32"] = 5] = "Bit32";
})(WireType || (WireType = {}));
var FLOAT32_MAX = 34028234663852886e22;
var FLOAT32_MIN = -34028234663852886e22;
var UINT32_MAX = 4294967295;
var INT32_MAX = 2147483647;
var INT32_MIN = -2147483648;
var BinaryWriter = class {
constructor(encodeUtf8 = getTextEncoding().encodeUtf8) {
this.encodeUtf8 = encodeUtf8;
this.stack = [];
this.chunks = [];
this.buf = [];
}
/**
* Return all bytes written and reset this writer.
*/
finish() {
this.chunks.push(new Uint8Array(this.buf));
let len = 0;
for (let i = 0; i < this.chunks.length; i++)
len += this.chunks[i].length;
let bytes = new Uint8Array(len);
let offset = 0;
for (let i = 0; i < this.chunks.length; i++) {
bytes.set(this.chunks[i], offset);
offset += this.chunks[i].length;
}
this.chunks = [];
return bytes;
}
/**
* Start a new fork for length-delimited data like a message
* or a packed repeated field.
*
* Must be joined later with `join()`.
*/
fork() {
this.stack.push({ chunks: this.chunks, buf: this.buf });
this.chunks = [];
this.buf = [];
return this;
}
/**
* Join the last fork. Write its length and bytes, then
* return to the previous state.
*/
join() {
let chunk = this.finish();
let prev = this.stack.pop();
if (!prev)
throw new Error("invalid state, fork stack empty");
this.chunks = prev.chunks;
this.buf = prev.buf;
this.uint32(chunk.byteLength);
return this.raw(chunk);
}
/**
* Writes a tag (field number and wire type).
*
* Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
*
* Generated code should compute the tag ahead of time and call `uint32()`.
*/
tag(fieldNo, type) {
return this.uint32((fieldNo << 3 | type) >>> 0);
}
/**
* Write a chunk of raw bytes.
*/
raw(chunk) {
if (this.buf.length) {
this.chunks.push(new Uint8Array(this.buf));
this.buf = [];
}
this.chunks.push(chunk);
return this;
}
/**
* Write a `uint32` value, an unsigned 32 bit varint.
*/
uint32(value) {
assertUInt32(value);
while (value > 127) {
this.buf.push(value & 127 | 128);
value = value >>> 7;
}
this.buf.push(value);
return this;
}
/**
* Write a `int32` value, a signed 32 bit varint.
*/
int32(value) {
assertInt32(value);
varint32write(value, this.buf);
return this;
}
/**
* Write a `bool` value, a variant.
*/
bool(value) {
this.buf.push(value ? 1 : 0);
return this;
}
/**
* Write a `bytes` value, length-delimited arbitrary data.
*/
bytes(value) {
this.uint32(value.byteLength);
return this.raw(value);
}
/**
* Write a `string` value, length-delimited data converted to UTF-8 text.
*/
string(value) {
let chunk = this.encodeUtf8(value);
this.uint32(chunk.byteLength);
return this.raw(chunk);
}
/**
* Write a `float` value, 32-bit floating point number.
*/
float(value) {
assertFloat32(value);
let chunk = new Uint8Array(4);
new DataView(chunk.buffer).setFloat32(0, value, true);
return this.raw(chunk);
}
/**
* Write a `double` value, a 64-bit floating point number.
*/
double(value) {
let chunk = new Uint8Array(8);
new DataView(chunk.buffer).setFloat64(0, value, true);
return this.raw(chunk);
}
/**
* Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
*/
fixed32(value) {
assertUInt32(value);
let chunk = new Uint8Array(4);
new DataView(chunk.buffer).setUint32(0, value, true);
return this.raw(chunk);
}
/**
* Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
*/
sfixed32(value) {
assertInt32(value);
let chunk = new Uint8Array(4);
new DataView(chunk.buffer).setInt32(0, value, true);
return this.raw(chunk);
}
/**
* Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
*/
sint32(value) {
assertInt32(value);
value = (value << 1 ^ value >> 31) >>> 0;
varint32write(value, this.buf);
return this;
}
/**
* Write a `fixed64` value, a signed, fixed-length 64-bit integer.
*/
sfixed64(value) {
let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
view.setInt32(0, tc.lo, true);
view.setInt32(4, tc.hi, true);
return this.raw(chunk);
}
/**
* Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
*/
fixed64(value) {
let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
view.setInt32(0, tc.lo, true);
view.setInt32(4, tc.hi, true);
return this.raw(chunk);
}
/**
* Write a `int64` value, a signed 64-bit varint.
*/
int64(value) {
let tc = protoInt64.enc(value);
varint64write(tc.lo, tc.hi, this.buf);
return this;
}
/**
* Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
*/
sint64(value) {
let tc = protoInt64.enc(value), sign = tc.hi >> 31, lo = tc.lo << 1 ^ sign, hi = (tc.hi << 1 | tc.lo >>> 31) ^ sign;
varint64write(lo, hi, this.buf);
return this;
}
/**
* Write a `uint64` value, an unsigned 64-bit varint.
*/
uint64(value) {
let tc = protoInt64.uEnc(value);
varint64write(tc.lo, tc.hi, this.buf);
return this;
}
};
var BinaryReader = class {
constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
this.decodeUtf8 = decodeUtf8;
this.varint64 = varint64read;
this.uint32 = varint32read;
this.buf = buf;
this.len = buf.length;
this.pos = 0;
this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
}
/**
* Reads a tag - field number and wire type.
*/
tag() {
let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
if (fieldNo <= 0 || wireType < 0 || wireType > 5)
throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
return [fieldNo, wireType];
}
/**
* Skip one element and return the skipped data.
*
* When skipping StartGroup, provide the tags field number to check for
* matching field number in the EndGroup tag.
*/
skip(wireType, fieldNo) {
let start = this.pos;
switch (wireType) {
case WireType.Varint:
while (this.buf[this.pos++] & 128) {
}
break;
// eslint-disable-next-line
// @ts-expect-error TS7029: Fallthrough case in switch
case WireType.Bit64:
this.pos += 4;
// eslint-disable-next-line no-fallthrough
case WireType.Bit32:
this.pos += 4;
break;
case WireType.LengthDelimited:
let len = this.uint32();
this.pos += len;
break;
case WireType.StartGroup:
for (; ; ) {
const [fn, wt] = this.tag();
if (wt === WireType.EndGroup) {
if (fieldNo !== void 0 && fn !== fieldNo) {
throw new Error("invalid end group tag");
}
break;
}
this.skip(wt, fn);
}
break;
default:
throw new Error("cant skip wire type " + wireType);
}
this.assertBounds();
return this.buf.subarray(start, this.pos);
}
/**
* Throws error if position in byte array is out of range.
*/
assertBounds() {
if (this.pos > this.len)
throw new RangeError("premature EOF");
}
/**
* Read a `int32` field, a signed 32 bit varint.
*/
int32() {
return this.uint32() | 0;
}
/**
* Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
*/
sint32() {
let zze = this.uint32();
return zze >>> 1 ^ -(zze & 1);
}
/**
* Read a `int64` field, a signed 64-bit varint.
*/
int64() {
return protoInt64.dec(...this.varint64());
}
/**
* Read a `uint64` field, an unsigned 64-bit varint.
*/
uint64() {
return protoInt64.uDec(...this.varint64());
}
/**
* Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
*/
sint64() {
let [lo, hi] = this.varint64();
let s = -(lo & 1);
lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
hi = hi >>> 1 ^ s;
return protoInt64.dec(lo, hi);
}
/**
* Read a `bool` field, a variant.
*/
bool() {
let [lo, hi] = this.varint64();
return lo !== 0 || hi !== 0;
}
/**
* Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
*/
fixed32() {
return this.view.getUint32((this.pos += 4) - 4, true);
}
/**
* Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
*/
sfixed32() {
return this.view.getInt32((this.pos += 4) - 4, true);
}
/**
* Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
*/
fixed64() {
return protoInt64.uDec(this.sfixed32(), this.sfixed32());
}
/**
* Read a `fixed64` field, a signed, fixed-length 64-bit integer.
*/
sfixed64() {
return protoInt64.dec(this.sfixed32(), this.sfixed32());
}
/**
* Read a `float` field, 32-bit floating point number.
*/
float() {
return this.view.getFloat32((this.pos += 4) - 4, true);
}
/**
* Read a `double` field, a 64-bit floating point number.
*/
double() {
return this.view.getFloat64((this.pos += 8) - 8, true);
}
/**
* Read a `bytes` field, length-delimited arbitrary data.
*/
bytes() {
let len = this.uint32(), start = this.pos;
this.pos += len;
this.assertBounds();
return this.buf.subarray(start, start + len);
}
/**
* Read a `string` field, length-delimited data converted to UTF-8 text.
*/
string() {
return this.decodeUtf8(this.bytes());
}
};
function assertInt32(arg) {
if (typeof arg == "string") {
arg = Number(arg);
} else if (typeof arg != "number") {
throw new Error("invalid int32: " + typeof arg);
}
if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
throw new Error("invalid int32: " + arg);
}
function assertUInt32(arg) {
if (typeof arg == "string") {
arg = Number(arg);
} else if (typeof arg != "number") {
throw new Error("invalid uint32: " + typeof arg);
}
if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
throw new Error("invalid uint32: " + arg);
}
function assertFloat32(arg) {
if (typeof arg == "string") {
const o = arg;
arg = Number(arg);
if (isNaN(arg) && o !== "NaN") {
throw new Error("invalid float32: " + o);
}
} else if (typeof arg != "number") {
throw new Error("invalid float32: " + typeof arg);
}
if (Number.isFinite(arg) && (arg > FLOAT32_MAX || arg < FLOAT32_MIN))
throw new Error("invalid float32: " + arg);
}
var protobufPackage = "fishjam";
var ServerMessage_EventType2 = /* @__PURE__ */ ((ServerMessage_EventType22) => {
ServerMessage_EventType22[ServerMessage_EventType22["EVENT_TYPE_UNSPECIFIED"] = 0] = "EVENT_TYPE_UNSPECIFIED";
ServerMessage_EventType22[ServerMessage_EventType22["EVENT_TYPE_SERVER_NOTIFICATION"] = 1] = "EVENT_TYPE_SERVER_NOTIFICATION";
ServerMessage_EventType22[ServerMessage_EventType22["EVENT_TYPE_METRICS"] = 2] = "EVENT_TYPE_METRICS";
ServerMessage_EventType22[ServerMessage_EventType22["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
return ServerMessage_EventType22;
})(ServerMessage_EventType2 || {});
function serverMessage_EventTypeFromJSON(object) {
switch (object) {
case 0:
case "EVENT_TYPE_UNSPECIFIED":
return 0;
case 1:
case "EVENT_TYPE_SERVER_NOTIFICATION":
return 1;
case 2:
case "EVENT_TYPE_METRICS":
return 2;
case -1:
case "UNRECOGNIZED":
default:
return -1;
}
}
function serverMessage_EventTypeToJSON(object) {
switch (object) {
case 0:
return "EVENT_TYPE_UNSPECIFIED";
case 1:
return "EVENT_TYPE_SERVER_NOTIFICATION";
case 2:
return "EVENT_TYPE_METRICS";
case -1:
default:
return "UNRECOGNIZED";
}
}
var ServerMessage_TrackType = /* @__PURE__ */ ((ServerMessage_TrackType2) => {
ServerMessage_TrackType2[ServerMessage_TrackType2["TRACK_TYPE_UNSPECIFIED"] = 0] = "TRACK_TYPE_UNSPECIFIED";
ServerMessage_TrackType2[ServerMessage_TrackType2["TRACK_TYPE_VIDEO"] = 1] = "TRACK_TYPE_VIDEO";
ServerMessage_TrackType2[ServerMessage_TrackType2["TRACK_TYPE_AUDIO"] = 2] = "TRACK_TYPE_AUDIO";
ServerMessage_TrackType2[ServerMessage_TrackType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
return ServerMessage_TrackType2;
})(ServerMessage_TrackType || {});
function serverMessage_TrackTypeFromJSON(object) {
switch (object) {
case 0:
case "TRACK_TYPE_UNSPECIFIED":
return 0;
case 1:
case "TRACK_TYPE_VIDEO":
return 1;
case 2:
case "TRACK_TYPE_AUDIO":
return 2;
case -1:
case "UNRECOGNIZED":
default:
return -1;
}
}
function serverMessage_TrackTypeToJSON(object) {
switch (object) {
case 0:
return "TRACK_TYPE_UNSPECIFIED";
case 1:
return "TRACK_TYPE_VIDEO";
case 2:
return "TRACK_TYPE_AUDIO";
case -1:
default:
return "UNRECOGNIZED";
}
}
function createBaseServerMessage() {
return {
roomCrashed: void 0,
peerConnected: void 0,
peerDisconnected: void 0,
peerCrashed: void 0,
componentCrashed: void 0,
authenticated: void 0,
authRequest: void 0,
subscribeRequest: void 0,
subscribeResponse: void 0,
roomCreated: void 0,
roomDeleted: void 0,
metricsReport: void 0,
hlsPlayable: void 0,
hlsUploaded: void 0,
hlsUploadCrashed: void 0,
peerMetadataUpdated: void 0,
trackAdded: void 0,
trackRemoved: void 0,
trackMetadataUpdated: void 0,
peerAdded: void 0,
peerDeleted: void 0
};
}
var ServerMessage2 = {
encode(message, writer = new BinaryWriter()) {
if (message.roomCrashed !== void 0) {
ServerMessage_RoomCrashed.encode(message.roomCrashed, writer.uint32(10).fork()).join();
}
if (message.peerConnected !== void 0) {
ServerMessage_PeerConnected.encode(message.peerConnected, writer.uint32(18).fork()).join();
}
if (message.peerDisconnected !== void 0) {
ServerMessage_PeerDisconnected.encode(message.peerDisconnected, writer.uint32(26).fork()).join();
}
if (message.peerCrashed !== void 0) {
ServerMessage_PeerCrashed.encode(message.peerCrashed, writer.uint32(34).fork()).join();
}
if (message.componentCrashed !== void 0) {
ServerMessage_ComponentCrashed.encode(message.componentCrashed, writer.uint32(42).fork()).join();
}
if (message.authenticated !== void 0) {
ServerMessage_Authenticated.encode(message.authenticated, writer.uint32(50).fork()).join();
}
if (message.authRequest !== void 0) {
ServerMessage_AuthRequest2.encode(message.authRequest, writer.uint32(58).fork()).join();
}
if (message.subscribeRequest !== void 0) {
ServerMessage_SubscribeRequest.encode(message.subscribeRequest, writer.uint32(66).fork()).join();
}
if (message.subscribeResponse !== void 0) {
ServerMessage_SubscribeResponse.encode(message.subscribeResponse, writer.uint32(74).fork()).join();
}
if (message.roomCreated !== void 0) {
ServerMessage_RoomCreated.encode(message.roomCreated, writer.uint32(82).fork()).join();
}
if (message.roomDeleted !== void 0) {
ServerMessage_RoomDeleted.encode(message.roomDeleted, writer.uint32(90).fork()).join();
}
if (message.metricsReport !== void 0) {
ServerMessage_MetricsReport.encode(message.metricsReport, writer.uint32(98).fork()).join();
}
if (message.hlsPlayable !== void 0) {
ServerMessage_HlsPlayable.encode(message.hlsPlayable, writer.uint32(106).fork()).join();
}
if (message.hlsUploaded !== void 0) {
ServerMessage_HlsUploaded.encode(message.hlsUploaded, writer.uint32(114).fork()).join();
}
if (message.hlsUploadCrashed !== void 0) {
ServerMessage_HlsUploadCrashed.encode(message.hlsUploadCrashed, writer.uint32(122).fork()).join();
}
if (message.peerMetadataUpdated !== void 0) {
ServerMessage_PeerMetadataUpdated.encode(message.peerMetadataUpdated, writer.uint32(130).fork()).join();
}
if (message.trackAdded !== void 0) {
ServerMessage_TrackAdded.encode(message.trackAdded, writer.uint32(138).fork()).join();
}
if (message.trackRemoved !== void 0) {
ServerMessage_TrackRemoved.encode(message.trackRemoved, writer.uint32(146).fork()).join();
}
if (message.trackMetadataUpdated !== void 0) {
ServerMessage_TrackMetadataUpdated.encode(message.trackMetadataUpdated, writer.uint32(154).fork()).join();
}
if (message.peerAdded !== void 0) {
ServerMessage_PeerAdded.encode(message.peerAdded, writer.uint32(162).fork()).join();
}
if (message.peerDeleted !== void 0) {
ServerMessage_PeerDeleted.encode(message.peerDeleted, writer.uint32(170).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === void 0 ? reader.len : reader.pos + length;
const message = createBaseServerMessage();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.roomCrashed = ServerMessage_RoomCrashed.decode(reader, reader.uint32());
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.peerConnected = ServerMessage_PeerConnected.decode(reader, reader.uint32());
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.peerDisconnected = ServerMessage_PeerDisconnected.decode(reader, reader.uint32());
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.peerCrashed = ServerMessage_PeerCrashed.decode(reader, reader.uint32());
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.componentCrashed = ServerMessage_ComponentCrashed.decode(reader, reader.uint32());
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.authenticated = ServerMessage_Authenticated.decode(reader, reader.uint32());
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.authRequest = ServerMessage_AuthRequest2.decode(reader, reader.uint32());
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.subscribeRequest = ServerMessage_SubscribeRequest.decode(reader, reader.uint32());
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.subscribeResponse = ServerMessage_SubscribeResponse.decode(reader, reader.uint32());
continue;
}
case 10: {
if (tag !== 82) {
break;
}
message.roomCreated = ServerMessage_RoomCreated.decode(reader, reader.uint32());
continue;
}
case 11: {
if (tag !== 90) {
break;
}
message.roomDeleted = ServerMessage_RoomDeleted.decode(reader, reader.uint32());
continue;
}
case 12: {
if (tag !== 98) {
break;
}
message.metricsReport = ServerMessage_MetricsReport.decode(reader, reader.uint32());
continue;
}
case 13: {
if (tag !== 106) {
break;
}
message.hlsPlayable = ServerMessage_HlsPlayable.decode(reader, reader.uint32());
continue;
}
case 14: {
if (tag !== 114) {
break;
}
message.hlsUploaded = ServerMessage_HlsUploaded.decode(reader, reader.uint32());
continue;
}
case 15: {
if (tag !== 122) {
break;
}
message.hlsUploadCrashed = ServerMessage_HlsUploadCrashed.decode(reader, reader.uint32());
continue;
}
case 16: {
if (tag !== 130) {
break;
}
message.peerMetadataUpdated = ServerMessage_PeerMetadataUpdated.decode(reader, reader.uint32());
continue;
}
case 17: {
if (tag !== 138) {
break;
}
message.trackAdded = ServerMessage_TrackAdded.decode(reader, reader.uint32());
continue;
}
case 18: {
if (tag !== 146) {
break;
}
message.trackRemoved = ServerMessage_TrackRemoved.decode(reader, reader.uint32());
continue;
}
case 19: {
if (tag !== 154) {
break;
}
message.trackMetadataUpdated = ServerMessage_TrackMetadataUpdated.decode(reader, reader.uint32());
continue;
}
case 20: {
if (tag !== 162) {
break;
}
message.peerAdded = ServerMessage_PeerAdded.decode(reader, reader.uint32());
continue;
}
case 21: {
if (tag !== 170) {
break;
}
message.peerDeleted = ServerMessage_PeerDeleted.decode(reader, reader.uint32());
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
roomCrashed: isSet(object.roomCrashed) ? ServerMessage_RoomCrashed.fromJSON(object.roomCrashed) : void 0,
peerConnected: isSet(object.peerConnected) ? ServerMessage_PeerConnected.fromJSON(object.peerConnected) : void 0,
peerDisconnected: isSet(object.peerDisconnected) ? ServerMessage_PeerDisconnected.fromJSON(object.peerDisconnected) : void 0,
peerCrashed: isSet(object.peerCrashed) ? ServerMessage_PeerCrashed.fromJSON(object.peerCrashed) : void 0,
componentCrashed: isSet(object.componentCrashed) ? ServerMessage_ComponentCrashed.fromJSON(object.componentCrashed) : void 0,
authenticated: isSet(object.authenticated) ? ServerMessage_Authenticated.fromJSON(object.authenticated) : void 0,
authRequest: isSet(object.authRequest) ? ServerMessage_AuthRequest2.fromJSON(object.authRequest) : void 0,
subscribeRequest: isSet(object.subscribeRequest) ? ServerMessage_SubscribeRequest.fromJSON(object.subscribeRequest) : void 0,
subscribeResponse: isSet(object.subscribeResponse) ? ServerMessage_SubscribeResponse.fromJSON(object.subscribeResponse) : void 0,
roomCreated: isSet(object.roomCreated) ? ServerMessage_RoomCreated.fromJSON(object.roomCreated) : void 0,
roomDeleted: isSet(object.roomDeleted) ? ServerMessage_RoomDeleted.fromJSON(object.roomDeleted) : void 0,
metricsReport: isSet(object.metricsReport) ? ServerMessage_MetricsReport.fromJSON(object.metricsReport) : void 0,
hlsPlayable: isSet(object.hlsPlayable) ? ServerMessage_HlsPlayable.fromJSON(object.hlsPlayable) : void 0,
hlsUploaded: isSet(object.hlsUploaded) ? ServerMessage_HlsUploaded.fromJSON(object.hlsUploaded) : void 0,
hlsUploadCrashed: isSet(object.hlsUploadCrashed) ? ServerMessage_HlsUploadCrashed.fromJSON(object.hlsUploadCrashed) : void 0,
peerMetadataUpdated: isSet(object.peerMetadataUpdated) ? ServerMessage_PeerMetadataUpdated.fromJSON(object.peerMetadataUpdated) : void 0,
trackAdded: isSet(object.trackAdded) ? ServerMessage_TrackAdded.fromJSON(object.trackAdded) : void 0,
trackRemoved: isSet(object.trackRemoved) ? ServerMessage_TrackRemoved.fromJSON(object.trackRemoved) : void 0,
trackMetadataUpdated: isSet(object.trackMetadataUpdated) ? ServerMessage_TrackMetadataUpdated.fromJSON(object.trackMetadataUpdated) : void 0,
peerAdded: isSet(object.peerAdded) ? ServerMessage_PeerAdded.fromJSON(object.peerAdded) : void 0,
peerDeleted: isSet(object.peerDeleted) ? ServerMessage_PeerDeleted.fromJSON(object.peerDeleted) : void 0
};
},
toJSON(message) {
const obj = {};
if (message.roomCrashed !== void 0) {
obj.roomCrashed = ServerMessage_RoomCrashed.toJSON(message.roomCrashed);
}
if (message.peerConnected !== void 0) {
obj.peerConnected = ServerMessage_PeerConnected.toJSON(message.peerConnected);
}
if (message.peerDisconnected !== void 0) {
obj.peerDisconnected = ServerMessage_PeerDisconnected.toJSON(message.peerDisconnected);
}
if (message.peerCrashed !== void 0) {
obj.peerCrashed = ServerMessage_PeerCrashed.toJSON(message.peerCrashed);
}
if (message.componentCrashed !== void 0) {
obj.componentCrashed = ServerMessage_ComponentCrashed.toJSON(message.componentCrashed);
}
if (message.authenticated !== void 0) {
obj.authenticated = ServerMessage_Authenticated.toJSON(message.authenticated);
}
if (message.authRequest !== void 0) {
obj.authRequest = ServerMessage_AuthRequest2.toJSON(message.authRequest);
}
if (message.subscribeRequest !== void 0) {
obj.subscribeRequest = ServerMessage_SubscribeRequest.toJSON(message.subscribeRequest);
}
if (message.subscribeResponse !== void 0) {
obj.subscribeResponse = ServerMessage_SubscribeResponse.toJSON(message.subscribeResponse);
}
if (message.roomCreated !== void 0) {
obj.roomCreated = ServerMessage_RoomCreated.toJSON(message.roomCreated);
}
if (message.roomDeleted !== void 0) {
obj.roomDeleted = ServerMessage_RoomDeleted.toJSON(message.roomDeleted);
}
if (message.metricsReport !== void 0) {
obj.metricsReport = ServerMessage_MetricsReport.toJSON(message.metricsReport);
}
if (message.hlsPlayable !== void 0) {
obj.hlsPlayable = ServerMessage_HlsPlayable.toJSON(message.hlsPlayable);
}
if (message.hlsUploaded !== void 0) {
obj.hlsUploaded = ServerMessage_HlsUploaded.toJSON(message.hlsUploaded);
}
if (message.hlsUploadCrashed !== void 0) {
obj.hlsUploadCrashed = ServerMessage_HlsUploadCrashed.toJSON(message.hlsUploadCrashed);
}
if (message.peerMetadataUpdated !== void 0) {
obj.peerMetadataUpdated = ServerMessage_PeerMetadataUpdated.toJSON(message.peerMetadataUpdated);
}
if (message.trackAdded !== void 0) {
obj.trackAdded = ServerMessage_TrackAdded.toJSON(message.trackAdded);
}
if (message.trackRemoved !== void 0) {
obj.trackRemoved = ServerMessage_TrackRemoved.toJSON(message.trackRemoved);
}
if (message.trackMetadataUpdated !== void 0) {
obj.trackMetadataUpdated = ServerMessage_TrackMetadataUpdated.toJSON(message.trackMetadataUpdated);
}
if (message.peerAdded !== void 0) {
obj.peerAdded = ServerMessage_PeerAdded.toJSON(message.peerAdded);
}
if (message.peerDeleted !== void 0) {
obj.peerDeleted = ServerMessage_PeerDeleted.toJSON(message.peerDeleted);
}
return obj;
},
create(base) {
return ServerMessage2.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseServerMessage();
message.roomCrashed = object.roomCrashed !== void 0 && object.roomCrashed !== null ? ServerMessage_RoomCrashed.fromPartial(object.roomCrashed) : void 0;
message.peerConnected = object.peerConnected !== void 0 && object.peerConnected !== null ? ServerMessage_PeerConnected.fromPartial(object.peerConnected) : void 0;
message.peerDisconnected = object.peerDisconnected !== void 0 && object.peerDisconnected !== null ? ServerMessage_PeerDisconnected.fromPartial(object.peerDisconnected) : void 0;
message.peerCrashed = object.peerCrashed !== void 0 && object.peerCrashed !== null ? ServerMessage_PeerCrashed.fromPartial(object.peerCrashed) : void 0;
message.componentCrashed = object.componentCrashed !== void 0 && object.componentCrashed !== null ? ServerMessage_ComponentCrashed.fromPartial(object.componentCrashed) : void 0;
message.authenticated = object.authenticated !== void 0 && object.authenticated !== null ? ServerMessage_Authenticated.fromPartial(object.authenticated) : void 0;
message.authRequest = object.authRequest !== void 0 && object.authRequest !== null ? ServerMessage_AuthRequest2.fromPartial(object.authRequest) : void 0;
message.subscribeRequest = object.subscribeRequest !== void 0 && object.subscribeRequest !== null ? ServerMessage_SubscribeRequest.fromPartial(object.subscribeRequest) : void 0;
message.subscribeResponse = object.subscribeResponse !== void 0 && object.subscribeResponse !== null ? ServerMessage_SubscribeResponse.fromPartial(object.subscribeResponse) : void 0;
message.roomCreated = object.roomCreated !== void 0 && object.roomCreated !== null ? ServerMessage_RoomCreated.fromPartial(object.roomCreated) : void 0;
message.roomDeleted = object.roomDeleted !== void 0 && object.roomDeleted !== null ? ServerMessage_RoomDeleted.fromPartial(object.roomDeleted) : void 0;
message.metricsReport = object.metricsReport !== void 0 && object.metricsReport !== null ? ServerMessage_MetricsReport.fromPartial(object.metricsReport) : void 0;
message.hlsPlayable = object.hlsPlayable !== void 0 && object.hlsPlayable !== null ? ServerMessage_HlsPlayable.fromPartial(object.hlsPlayable) : void 0;
message.hlsUploaded = object.hlsUploaded !== void 0 && object.hlsUploaded !== null ? ServerMessage_HlsUploaded.fromPartial(object.hlsUploaded) : void 0;
message.hlsUploadCrashed = object.hlsUploadCrashed !== void 0 && object.hlsUploadCrashed !== null ? ServerMessage_HlsUploadCrashed.fromPartial(object.hlsUploadCrashed) : void 0;
message.peerMetadataUpdated = object.peerMetadataUpdated !== void 0 && object.peerMetadataUpdated !== null ? ServerMessage_PeerMetadataUpdated.fromPartial(object.peerMetadataUpdated) : void 0;
message.trackAdded = object.trackAdded !== void 0 && object.trackAdded !== null ? ServerMessage_TrackAdded.fromPartial(object.trackAdded) : void 0;
message.trackRemoved = object.trackRemoved !== void 0 && object.trackRemoved !== null ? ServerMessage_TrackRemoved.fromPartial(object.trackRemoved) : void 0;
message.trackMetadataUpdated = object.trackMetadataUpdated !== void 0 && object.trackMetadataUpdated !== null ? ServerMessage_TrackMetadataUpdated.fromPartial(object.trackMetadataUpdated) : void 0;
message.peerAdded = object.peerAdded !== void 0 && object.peerAdded !== null ? ServerMessage_PeerAdded.fromPartial(object.peerAdded) : void 0;
message.peerDeleted = object.peerDeleted !== void 0 && object.peerDeleted !== null ? ServerMessage_PeerDeleted.fromPartial(object.peerDeleted) : void 0;
return message;
}
};
function createBaseServerMessage_RoomCrashed() {
return { roomId: "" };
}
var ServerMessage_RoomCrashed = {
encode(message, writer = new BinaryWriter()) {
if (message.roomId !== "") {
writer.uint32(10).string(message.roomId);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
let end = length === void 0 ? reader.len : reader.pos + length;
const message = createBaseServerMessage_RoomCrashed();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.roomId = reader.string();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return { roomId: isSet(object.roomId) ? globalThis.String(object.roomId) : "" };
},
toJSON(message) {
const obj = {};
if (message.roomId !== "") {