@bitrix24/b24jssdk/dist/esm/pullClient/protobuf-lite/messages.mjs

Bitrix24 REST API JavaScript SDK

/**
 * @package @bitrix24/b24jssdk
 * @version 3.0.0
 * @copyright (c) 2026 Bitrix24
 * @license MIT
 * @see https://github.com/bitrix24/b24jssdk
 * @see https://bitrix24.github.io/b24jssdk/
 */
import { Writer, tag, WIRE_BYTES, WIRE_VARINT, Reader, WireError, WIRE_FIXED32 } from './wire.mjs';

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
function has(source, key) {
  return Object.hasOwn(source, key) && source[key] !== null && source[key] !== void 0;
}
__name(has, "has");
function writeReceiver(receiver) {
  const w = new Writer();
  if (has(receiver, "id")) {
    w.varint(tag(1, WIRE_BYTES)).bytes(receiver.id);
  }
  if (has(receiver, "isPrivate")) {
    w.varint(tag(2, WIRE_VARINT)).varint(receiver.isPrivate ? 1 : 0);
  }
  if (has(receiver, "signature")) {
    w.varint(tag(3, WIRE_BYTES)).bytes(receiver.signature);
  }
  return w.finish();
}
__name(writeReceiver, "writeReceiver");
function writeSender(sender) {
  const w = new Writer();
  if (has(sender, "type")) {
    w.varint(tag(1, WIRE_VARINT)).varint(sender.type);
  }
  if (has(sender, "id")) {
    w.varint(tag(2, WIRE_BYTES)).bytes(sender.id);
  }
  return w.finish();
}
__name(writeSender, "writeSender");
function writeIncomingMessage(message) {
  const w = new Writer();
  for (const receiver of message.receivers ?? []) {
    w.varint(tag(1, WIRE_BYTES)).bytes(writeReceiver(receiver));
  }
  if (has(message, "sender")) {
    w.varint(tag(2, WIRE_BYTES)).bytes(writeSender(message.sender));
  }
  if (has(message, "body")) {
    w.varint(tag(3, WIRE_BYTES)).string(message.body);
  }
  if (has(message, "expiry")) {
    w.varint(tag(4, WIRE_VARINT)).varint(message.expiry);
  }
  if (has(message, "type")) {
    w.varint(tag(5, WIRE_BYTES)).string(message.type);
  }
  return w.finish();
}
__name(writeIncomingMessage, "writeIncomingMessage");
function encodeRequestBatch(messages) {
  const messagesRequest = new Writer();
  for (const message of messages) {
    messagesRequest.varint(tag(1, WIRE_BYTES)).bytes(writeIncomingMessage(message));
  }
  const request = new Writer();
  request.varint(tag(1, WIRE_BYTES)).bytes(messagesRequest.finish());
  const batch = new Writer();
  batch.varint(tag(1, WIRE_BYTES)).bytes(request.finish());
  return batch.finish();
}
__name(encodeRequestBatch, "encodeRequestBatch");
function readFields(view, flag, onField) {
  const r = new Reader(view);
  while (!r.done) {
    try {
      const key = r.varint();
      onField(key >>> 3, key & 7, r);
    } catch (error) {
      if (!(error instanceof WireError)) {
        throw error;
      }
      flag.damaged = true;
      return;
    }
  }
}
__name(readFields, "readFields");
function readSender(view, flag) {
  const sender = { type: 0, id: new Uint8Array(0) };
  readFields(view, flag, (field, wireType, r) => {
    if (field === 1 && wireType === WIRE_VARINT) {
      sender.type = r.uint32();
    } else if (field === 2 && wireType === WIRE_BYTES) {
      sender.id = r.bytes();
    } else {
      r.skip(wireType);
    }
  });
  return sender;
}
__name(readSender, "readSender");
function readOutgoingMessage(view, flag) {
  const message = {
    id: new Uint8Array(0),
    body: "",
    expiry: 0,
    created: 0
  };
  readFields(view, flag, (field, wireType, r) => {
    if (field === 1 && wireType === WIRE_BYTES) {
      message.id = r.bytes();
    } else if (field === 2 && wireType === WIRE_BYTES) {
      message.body = r.string();
    } else if (field === 3 && wireType === WIRE_VARINT) {
      message.expiry = r.uint32();
    } else if (field === 4 && wireType === WIRE_FIXED32) {
      message.created = r.fixed32();
    } else if (field === 5 && wireType === WIRE_BYTES) {
      message.sender = readSender(r.bytes(), flag);
    } else {
      r.skip(wireType);
    }
  });
  return message;
}
__name(readOutgoingMessage, "readOutgoingMessage");
function readOutgoingMessagesResponse(view, flag) {
  const messages = [];
  readFields(view, flag, (field, wireType, r) => {
    if (field === 1 && wireType === WIRE_BYTES) {
      messages.push(readOutgoingMessage(r.bytes(), flag));
    } else {
      r.skip(wireType);
    }
  });
  return { messages };
}
__name(readOutgoingMessagesResponse, "readOutgoingMessagesResponse");
function readResponse(view, flag) {
  const response = {};
  readFields(view, flag, (field, wireType, r) => {
    if (field === 1 && wireType === WIRE_BYTES) {
      response.outgoingMessages = readOutgoingMessagesResponse(r.bytes(), flag);
      response.command = "outgoingMessages";
    } else if (field === 2 && wireType === WIRE_BYTES) {
      r.bytes();
      response.command = "channelStats";
    } else if (field === 3 && wireType === WIRE_BYTES) {
      r.bytes();
      response.command = "serverStats";
    } else {
      r.skip(wireType);
    }
  });
  return response;
}
__name(readResponse, "readResponse");
function decodeResponseBatch(view) {
  const flag = { damaged: false };
  const responses = [];
  readFields(view, flag, (field, wireType, r) => {
    if (field === 1 && wireType === WIRE_BYTES) {
      responses.push(readResponse(r.bytes(), flag));
    } else {
      r.skip(wireType);
    }
  });
  return { responses, damaged: flag.damaged };
}
__name(decodeResponseBatch, "decodeResponseBatch");

export { decodeResponseBatch, encodeRequestBatch };
//# sourceMappingURL=messages.mjs.map