nodejs-insta-private-api-mqt 1.3.73 → 1.3.74

package/dist/thrift/thrift.writing.js

@@ -3,340 +3,394 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferWriter = exports.thriftWriteFromObject = void 0;
 const thrift_1 = require("./thrift");
 const errors_1 = require("../errors");
+
+/**
+ * Thrift Compact Protocol writer (subset) optimized for MQTT-over-Thrift payloads.
+ * Improvements vs old version:
+ * - avoids Buffer.concat per write (uses chunk list + lazy concat)
+ * - faster descriptor lookup via Map
+ * - more flexible INT_64 input (number|bigint|string|{int}|Long-like)
+ */
+
 function thriftWriteFromObject(obj, descriptors) {
-    const writer = BufferWriter.empty();
-    thriftWriteSingleLayerFromObject(obj, descriptors, writer);
-    writer.writeStop();
-    return writer.buffer;
+  const writer = BufferWriter.empty();
+  thriftWriteSingleLayerFromObject(obj, descriptors, writer);
+  writer.writeStop();
+  return writer.buffer;
 }
 exports.thriftWriteFromObject = thriftWriteFromObject;
+
+function buildDescriptorMap(descriptors) {
+  const map = new Map();
+  for (const d of descriptors) map.set(d.fieldName, d);
+  return map;
+}
+
+function normalizeInt64(v, nameForError) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") return BigInt(v);
+  if (typeof v === "string") return BigInt(v);
+  if (v && typeof v === "object") {
+    if (typeof v.int === "bigint") return v.int; // our reader shape
+    if (typeof v.toString === "function") return BigInt(v.toString());
+  }
+  throw new errors_1.IllegalArgumentError(`Value of ${nameForError} is neither a bigint nor a number/string`);
+}
+
 function thriftWriteSingleLayerFromObject(obj, descriptors, writer) {
-    const entries = Object.entries(obj);
-    for (const entry of entries) {
-        const name = entry[0];
-        const value = entry[1];
-        if (typeof value === 'undefined')
-            continue;
-        const descriptor = descriptors.find(d => d.fieldName === name);
-        if (!descriptor)
-            throw new errors_1.IllegalArgumentError(`Descriptor for ${name} not found`);
-        switch (descriptor.type & 0xff) {
-            case thrift_1.ThriftTypes.BOOLEAN:
-            case thrift_1.ThriftTypes.TRUE:
-            case thrift_1.ThriftTypes.FALSE: {
-                writer.writeBoolean(descriptor.field, !!value);
-                break;
-            }
-            case thrift_1.ThriftTypes.BYTE: {
-                if (typeof value === 'number') {
-                    writer.writeInt8(descriptor.field, value);
-                }
-                else {
-                    throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
-                }
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_16: {
-                if (typeof value === 'number') {
-                    writer.writeInt16(descriptor.field, value);
-                }
-                else {
-                    throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
-                }
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_32: {
-                if (typeof value === 'number') {
-                    writer.writeInt32(descriptor.field, value);
-                }
-                else {
-                    throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
-                }
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_64: {
-                if (typeof value === 'number') {
-                    writer.writeInt64Buffer(descriptor.field, BigInt(value));
-                }
-                else if (typeof value === 'bigint') {
-                    writer.writeInt64Buffer(descriptor.field, value);
-                }
-                else {
-                    throw new errors_1.IllegalArgumentError(`Value of ${name} is neither a bigint nor a number`);
-                }
-                break;
-            }
-            case thrift_1.ThriftTypes.LIST: {
-                // @ts-ignore
-                writer.writeList(descriptor.field, descriptor.type >> 8, value);
-                break;
-            }
-            case thrift_1.ThriftTypes.STRUCT: {
-                writer.writeStruct(descriptor.field);
-                thriftWriteSingleLayerFromObject(value, descriptor.structDescriptors ?? [], writer);
-                writer.writeStop();
-                break;
-            }
-            case thrift_1.ThriftTypes.BINARY: {
-                if (typeof value === 'string') {
-                    writer.writeString(descriptor.field, value);
-                }
-                else {
-                    throw new errors_1.IllegalArgumentError(`Value of ${name} is not a string`);
-                }
-                break;
-            }
-            case thrift_1.ThriftTypes.MAP: {
-                if (descriptor.type === thrift_1.ThriftTypes.MAP_BINARY_BINARY) {
-                    let pairs;
-                    if (Array.isArray(value)) {
-                        //[{key: 'a', value: 'b'}]
-                        pairs = value.map((x) => [x.key, x.value]);
-                    }
-                    else {
-                        // {a: 'b'}
-                        pairs = Object.entries(value);
-                    }
-                    writer.writeMapHeader(descriptor.field, pairs.length, thrift_1.ThriftTypes.BINARY, thrift_1.ThriftTypes.BINARY);
-                    if (pairs.length !== 0) {
-                        for (const pair of pairs) {
-                            writer.writeStringDirect(pair[0]).writeStringDirect(pair[1]);
-                        }
-                    }
-                }
-                else {
-                    throw new errors_1.ThriftError(`Map of type ${descriptor.type} not impl.`);
-                }
-                break;
-            }
-            default: {
-                throw new errors_1.ThriftError(`Could not find type ${descriptor.type} for ${name}`);
-            }
+  const descriptorMap = buildDescriptorMap(descriptors);
+  const entries = Object.entries(obj);
+
+  for (const [name, value] of entries) {
+    if (typeof value === "undefined") continue;
+
+    const descriptor = descriptorMap.get(name);
+    if (!descriptor) throw new errors_1.IllegalArgumentError(`Descriptor for ${name} not found`);
+
+    switch (descriptor.type & 0xff) {
+      case thrift_1.ThriftTypes.BOOLEAN:
+      case thrift_1.ThriftTypes.TRUE:
+      case thrift_1.ThriftTypes.FALSE: {
+        writer.writeBoolean(descriptor.field, !!value);
+        break;
+      }
+      case thrift_1.ThriftTypes.BYTE: {
+        if (typeof value === "number") writer.writeInt8(descriptor.field, value);
+        else throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_16: {
+        if (typeof value === "number") writer.writeInt16(descriptor.field, value);
+        else throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_32: {
+        if (typeof value === "number") writer.writeInt32(descriptor.field, value);
+        else throw new errors_1.IllegalArgumentError(`Value of ${name} is not a number`);
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_64: {
+        writer.writeInt64Buffer(descriptor.field, normalizeInt64(value, name));
+        break;
+      }
+      case thrift_1.ThriftTypes.LIST: {
+        // packed list type is stored in high byte (descriptor.type >> 8)
+        // @ts-ignore
+        writer.writeList(descriptor.field, descriptor.type >> 8, value);
+        break;
+      }
+      case thrift_1.ThriftTypes.STRUCT: {
+        writer.writeStruct(descriptor.field);
+        thriftWriteSingleLayerFromObject(value, descriptor.structDescriptors ?? [], writer);
+        writer.writeStop();
+        break;
+      }
+      case thrift_1.ThriftTypes.BINARY: {
+        if (typeof value === "string") writer.writeString(descriptor.field, value);
+        else throw new errors_1.IllegalArgumentError(`Value of ${name} is not a string`);
+        break;
+      }
+      case thrift_1.ThriftTypes.MAP: {
+        if (descriptor.type === thrift_1.ThriftTypes.MAP_BINARY_BINARY) {
+          let pairs;
+          if (Array.isArray(value)) {
+            // [{key:'a', value:'b'}]
+            pairs = value.map((x) => [x.key, x.value]);
+          } else {
+            // {a:'b'}
+            pairs = Object.entries(value);
+          }
+          writer.writeMapHeader(descriptor.field, pairs.length, thrift_1.ThriftTypes.BINARY, thrift_1.ThriftTypes.BINARY);
+          if (pairs.length !== 0) {
+            for (const [k, v] of pairs) writer.writeStringDirect(k).writeStringDirect(v);
+          }
+        } else {
+          throw new errors_1.ThriftError(`Map of type ${descriptor.type} not impl.`);
         }
+        break;
+      }
+      default: {
+        throw new errors_1.ThriftError(`Could not find type ${descriptor.type} for ${name}`);
+      }
     }
+  }
 }
+
 class BufferWriter {
-    get buffer() {
-        return this._buffer;
-    }
-    get position() {
-        return this._position;
-    }
-    get length() {
-        return this._buffer.length;
-    }
-    get field() {
-        return this._field;
-    }
-    get stack() {
-        return this._stack;
-    }
-    constructor(data, length, buffer) {
-        this._position = 0;
-        this._field = 0;
-        this._stack = [];
-        this._buffer = data ? Buffer.from(data) : length ? Buffer.alloc(length) : buffer ? buffer : Buffer.from([]);
-        this._position = 0;
-    }
-    static fromLength(len) {
-        return new BufferWriter(undefined, len, undefined);
-    }
-    static fromBuffer(buf) {
-        return new BufferWriter(undefined, undefined, buf);
-    }
-    static fromString(data) {
-        return new BufferWriter(data, undefined, undefined);
-    }
-    static empty() {
-        return new BufferWriter(undefined, undefined, undefined);
-    }
-    move(bytes) {
-        this._position = this._position + bytes;
-        return this._position - bytes;
-    }
-    writeVarInt(num) {
-        while (true) {
-            let byte = num & ~0x7f;
-            if (byte === 0) {
-                this.writeByte(num);
-                break;
-            }
-            else if (byte === -128) {
-                // -128 = 0b1000_0000 but it's the last an no other bytes will follow
-                this.writeByte(0);
-                break;
-            }
-            else {
-                byte = (num & 0xff) | 0x80;
-                this.writeByte(byte);
-                num = num >> 7;
-            }
-        }
-        return this;
-    }
-    writeField(field, type) {
-        const delta = field - this.field;
-        if (delta > 0 && delta <= 15) {
-            this.writeByte((delta << 4) | type);
-        }
-        else {
-            this.writeByte(type);
-            this.writeWord(field);
-        }
-        this._field = field;
-        return this;
-    }
-    writeBuffer(buf) {
-        this._buffer = Buffer.concat([this._buffer, buf]);
-        this.move(buf.length);
-        return this;
-    }
-    writeByte(byte) {
-        const buf = Buffer.alloc(1);
-        buf.writeUInt8(byte, 0);
-        this.writeBuffer(buf);
-        return this;
-    }
-    writeWord(num) {
-        return this.writeVarInt(BufferWriter.toZigZag(num, 0x10));
-    }
-    writeInt(num) {
-        return this.writeVarInt(BufferWriter.toZigZag(num, 0x20));
-    }
-    writeLong(num) {
-        if (typeof num === 'object') {
-            num = num.int;
-        }
-        if (typeof num !== 'bigint') {
-            num = BigInt(num);
-        }
-        this.writeBigint(BufferWriter.bigintToZigZag(num));
-        return this;
-    }
-    writeBigint(n) {
-        while (true) {
-            if ((n & ~BigInt(0x7f)) === BigInt(0)) {
-                this.writeByte(Number(n));
-                break;
-            }
-            else {
-                this.writeByte(Number((n & BigInt(0x7f)) | BigInt(0x80)));
-                n = n >> BigInt(7);
-            }
-        }
-    }
-    writeMapHeader(field, size, keyType, valueType) {
-        this.writeField(field, thrift_1.ThriftTypes.MAP);
-        if (size === 0) {
-            this.writeByte(0);
-        }
-        else {
-            this.writeVarInt(size);
-            this.writeByte(((keyType & 0xf) << 4) | (valueType & 0xf));
-        }
-        return this;
-    }
-    writeBoolean(field, bool) {
-        return this.writeField(field, bool ? thrift_1.ThriftTypes.TRUE : thrift_1.ThriftTypes.FALSE);
-    }
-    writeString(field, s) {
-        this.writeField(field, thrift_1.ThriftTypes.BINARY);
-        return this.writeStringDirect(s);
-    }
-    writeStringDirect(s) {
-        const buf = Buffer.from(s, 'utf8');
-        this.writeVarInt(buf.length);
-        this.writeBuffer(buf);
-        return this;
-    }
-    writeStop() {
-        this.writeByte(thrift_1.ThriftTypes.STOP);
-        if (this.stack.length > 0) {
-            this.popStack();
-        }
-        return this;
-    }
-    writeInt8(field, num) {
-        this.writeField(field, thrift_1.ThriftTypes.BYTE);
-        return this.writeByte(num);
-    }
-    writeInt16(field, num) {
-        this.writeField(field, thrift_1.ThriftTypes.INT_16);
-        return this.writeWord(num);
-    }
-    writeInt32(field, num) {
-        this.writeField(field, thrift_1.ThriftTypes.INT_32);
-        return this.writeInt(num);
-    }
-    writeInt64Buffer(field, num) {
-        this.writeField(field, thrift_1.ThriftTypes.INT_64);
-        return this.writeLong(num);
-    }
-    writeList(field, type, list) {
-        this.writeField(field, thrift_1.ThriftTypes.LIST);
-        const size = list.length;
-        if (size < 0x0f) {
-            this.writeByte((size << 4) | type);
-        }
-        else {
-            this.writeByte(0xf0 | type);
-            this.writeVarInt(size);
-        }
-        switch (type) {
-            case thrift_1.ThriftTypes.TRUE:
-            case thrift_1.ThriftTypes.FALSE: {
-                list.forEach(el => this.writeByte(el ? thrift_1.ThriftTypes.TRUE : thrift_1.ThriftTypes.FALSE));
-                break;
-            }
-            case thrift_1.ThriftTypes.BYTE: {
-                list.forEach(el => this.writeByte(el));
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_16: {
-                list.forEach(el => this.writeWord(el));
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_32: {
-                list.forEach(el => this.writeInt(el));
-                break;
-            }
-            case thrift_1.ThriftTypes.INT_64: {
-                list.forEach(el => this.writeLong(BigInt(el)));
-                break;
-            }
-            case thrift_1.ThriftTypes.BINARY: {
-                list.forEach(el => {
-                    const buf = Buffer.from(el, 'utf8');
-                    this.writeVarInt(buf.length);
-                    this.writeBuffer(buf);
-                });
-                break;
-            }
-            default: {
-                throw new errors_1.ThriftError('not impl');
-            }
-        }
-        return this;
-    }
-    writeStruct(field) {
-        this.writeField(field, thrift_1.ThriftTypes.STRUCT);
-        this.pushStack();
-        return this;
-    }
-    pushStack() {
-        this._stack.push(this.field);
-        this._field = 0;
-    }
-    popStack() {
-        this._field = this._stack.pop() ?? -1;
-    }
-    toString() {
-        return this._buffer.toString('ascii');
-    }
-    static bigintToZigZag(n) {
-        return (n << BigInt(1)) ^ (n >> BigInt(63));
-    }
+  get buffer() {
+    // Lazy concat: only when requested
+    if (this._dirty) {
+      this._buffer = Buffer.concat(this._chunks, this._length);
+      this._dirty = false;
+      // free chunks to reduce memory, keep single buffer from now on
+      this._chunks = [this._buffer];
+    }
+    return this._buffer;
+  }
+  get position() {
+    return this._position;
+  }
+  get length() {
+    return this._length;
+  }
+  get field() {
+    return this._field;
+  }
+  get stack() {
+    return this._stack;
+  }
+
+  constructor(data, length, buffer) {
+    this._position = 0;
+    this._field = 0;
+    this._stack = [];
+
+    // internal chunked buffer state
+    this._chunks = [];
+    this._length = 0;
+    this._dirty = true;
+
+    if (data) {
+      const b = Buffer.from(data);
+      this._chunks.push(b);
+      this._length = b.length;
+      this._buffer = b;
+      this._dirty = false;
+    } else if (typeof length === "number") {
+      // not used in current library, but keep for compatibility
+      const b = Buffer.alloc(length);
+      this._chunks.push(b);
+      this._length = b.length;
+      this._buffer = b;
+      this._dirty = false;
+    } else if (buffer) {
+      this._chunks.push(buffer);
+      this._length = buffer.length;
+      this._buffer = buffer;
+      this._dirty = false;
+    } else {
+      const b = Buffer.from([]);
+      this._chunks.push(b);
+      this._length = 0;
+      this._buffer = b;
+      this._dirty = false;
+    }
+  }
+
+  static fromLength(len) {
+    return new BufferWriter(undefined, len, undefined);
+  }
+  static fromBuffer(buf) {
+    return new BufferWriter(undefined, undefined, buf);
+  }
+  static fromString(data) {
+    return new BufferWriter(data, undefined, undefined);
+  }
+  static empty() {
+    return new BufferWriter(undefined, undefined, undefined);
+  }
+
+  move(bytes) {
+    this._position = this._position + bytes;
+    return this._position - bytes;
+  }
+
+  writeVarInt(num) {
+    // num is int32-ish here
+    while (true) {
+      let byte = num & ~0x7f;
+      if (byte === 0) {
+        this.writeByte(num);
+        break;
+      } else if (byte === -128) {
+        // -128 = 0b1000_0000 but it's the last and no other bytes will follow
+        this.writeByte(0);
+        break;
+      } else {
+        byte = (num & 0xff) | 0x80;
+        this.writeByte(byte);
+        num = num >> 7;
+      }
+    }
+    return this;
+  }
+
+  writeField(field, type) {
+    const delta = field - this.field;
+    if (delta > 0 && delta <= 15) {
+      this.writeByte((delta << 4) | type);
+    } else {
+      this.writeByte(type);
+      this.writeWord(field);
+    }
+    this._field = field;
+    return this;
+  }
+
+  writeBuffer(buf) {
+    // Chunk append (no concat)
+    if (!buf || buf.length === 0) return this;
+    this._chunks.push(buf);
+    this._length += buf.length;
+    this._dirty = true;
+    this.move(buf.length);
+    return this;
+  }
+
+  writeByte(byte) {
+    const b = Buffer.allocUnsafe(1);
+    b[0] = byte & 0xff;
+    return this.writeBuffer(b);
+  }
+
+  writeWord(num) {
+    return this.writeVarInt(BufferWriter.toZigZag(num, 0x10));
+  }
+  writeInt(num) {
+    return this.writeVarInt(BufferWriter.toZigZag(num, 0x20));
+  }
+
+  writeLong(num) {
+    if (typeof num === "object") num = num.int;
+    if (typeof num !== "bigint") num = BigInt(num);
+    this.writeBigint(BufferWriter.bigintToZigZag(num));
+    return this;
+  }
+
+  writeBigint(n) {
+    while (true) {
+      if ((n & ~BigInt(0x7f)) === BigInt(0)) {
+        this.writeByte(Number(n));
+        break;
+      } else {
+        this.writeByte(Number((n & BigInt(0x7f)) | BigInt(0x80)));
+        n = n >> BigInt(7);
+      }
+    }
+  }
+
+  writeMapHeader(field, size, keyType, valueType) {
+    this.writeField(field, thrift_1.ThriftTypes.MAP);
+    if (size === 0) {
+      this.writeByte(0);
+    } else {
+      this.writeVarInt(size);
+      this.writeByte(((keyType & 0xf) << 4) | (valueType & 0xf));
+    }
+    return this;
+  }
+
+  writeBoolean(field, bool) {
+    return this.writeField(field, bool ? thrift_1.ThriftTypes.TRUE : thrift_1.ThriftTypes.FALSE);
+  }
+
+  writeString(field, s) {
+    this.writeField(field, thrift_1.ThriftTypes.BINARY);
+    return this.writeStringDirect(s);
+  }
+
+  writeStringDirect(s) {
+    const buf = Buffer.from(s, "utf8");
+    this.writeVarInt(buf.length);
+    this.writeBuffer(buf);
+    return this;
+  }
+
+  writeStop() {
+    this.writeByte(thrift_1.ThriftTypes.STOP);
+    if (this.stack.length > 0) this.popStack();
+    return this;
+  }
+
+  writeInt8(field, num) {
+    this.writeField(field, thrift_1.ThriftTypes.BYTE);
+    return this.writeByte(num);
+  }
+  writeInt16(field, num) {
+    this.writeField(field, thrift_1.ThriftTypes.INT_16);
+    return this.writeWord(num);
+  }
+  writeInt32(field, num) {
+    this.writeField(field, thrift_1.ThriftTypes.INT_32);
+    return this.writeInt(num);
+  }
+  writeInt64Buffer(field, num) {
+    this.writeField(field, thrift_1.ThriftTypes.INT_64);
+    return this.writeLong(num);
+  }
+
+  writeList(field, type, list) {
+    this.writeField(field, thrift_1.ThriftTypes.LIST);
+    const size = list.length;
+
+    if (size < 0x0f) {
+      this.writeByte((size << 4) | type);
+    } else {
+      this.writeByte(0xf0 | type);
+      this.writeVarInt(size);
+    }
+
+    switch (type) {
+      case thrift_1.ThriftTypes.TRUE:
+      case thrift_1.ThriftTypes.FALSE: {
+        list.forEach((el) => this.writeByte(el ? thrift_1.ThriftTypes.TRUE : thrift_1.ThriftTypes.FALSE));
+        break;
+      }
+      case thrift_1.ThriftTypes.BYTE: {
+        list.forEach((el) => this.writeByte(el));
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_16: {
+        list.forEach((el) => this.writeWord(el));
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_32: {
+        list.forEach((el) => this.writeInt(el));
+        break;
+      }
+      case thrift_1.ThriftTypes.INT_64: {
+        list.forEach((el) => this.writeLong(normalizeInt64(el, "list<int64> item")));
+        break;
+      }
+      case thrift_1.ThriftTypes.BINARY: {
+        list.forEach((el) => {
+          const buf = Buffer.from(el, "utf8");
+          this.writeVarInt(buf.length);
+          this.writeBuffer(buf);
+        });
+        break;
+      }
+      default: {
+        throw new errors_1.ThriftError("not impl");
+      }
+    }
+
+    return this;
+  }
+
+  writeStruct(field) {
+    this.writeField(field, thrift_1.ThriftTypes.STRUCT);
+    this.pushStack();
+    return this;
+  }
+
+  pushStack() {
+    this._stack.push(this.field);
+    this._field = 0;
+  }
+  popStack() {
+    this._field = this._stack.pop() ?? -1;
+  }
+
+  toString() {
+    return this.buffer.toString("ascii");
+  }
+
+  static bigintToZigZag(n) {
+    return (n << BigInt(1)) ^ (n >> BigInt(63));
+  }
 }
 exports.BufferWriter = BufferWriter;
+
 BufferWriter.toZigZag = (n, bits) => (n << 1) ^ (n >> (bits - 1));
-//# sourceMappingURL=thrift.writing.js.map
+