@jsprismarine/binaryutils 0.15.0-unstable-20261024002035

package/dist/BinaryStream.d.ts

@@ -0,0 +1,488 @@
+/**
+ * A high-performance binary stream for reading and writing binary data.
+ *
+ * Unlike Node.js native buffers which have fixed size, BinaryStream uses dynamic
+ * buffers that grow automatically during write operations. This eliminates the need
+ * for manual resizing or inefficient `Buffer.concat()` calls.
+ *
+ * @example Reading data
+ * ```typescript
+ * const stream = new BinaryStream(buffer);
+ * const value = stream.readInt();
+ * ```
+ *
+ * @example Writing data
+ * ```typescript
+ * const stream = new BinaryStream();
+ * stream.writeInt(42);
+ * stream.write(Buffer.from('Hello'));  // Buffer grows automatically
+ * const buffer = stream.getWriteBuffer();
+ * ```
+ *
+ * @example Encoding many packets without allocating
+ * ```typescript
+ * const stream = new BinaryStream(undefined, 0, 4096);
+ * for (const packet of queue) {
+ *     stream.resetWrite();
+ *     packet.encode(stream);
+ *     offset = stream.copyInto(arena, offset);
+ * }
+ * ```
+ */
+export declare class BinaryStream {
+    private writeBuffer;
+    private readBuffer;
+    private readIndex;
+    private writeIndex;
+    private writeCapacity;
+    /**
+     * Creates a new BinaryStream instance.
+     * @param {Buffer|null|undefined} buffer - The array or Buffer containing binary data.
+     * @param {number} offset - The initial pointer position.
+     * @param {number} initialCapacity - Pre-allocates the write buffer to this size. Use it when
+     * the encoded size is known up front: it skips the 256 -> 512 -> 1024 ... growth ladder, and
+     * with {@link resetWrite} it lets a long-lived encoder run without allocating at all.
+     */
+    constructor(buffer?: Buffer, offset?: number, initialCapacity?: number);
+    /**
+     * Reads a slice of buffer by the given length.
+     * @param {number} len
+     */
+    read(len: number): Buffer;
+    /**
+     * Appends a buffer to the main buffer.
+     * @param {Buffer|Uint8Array} buf
+     */
+    write(buf: Uint8Array): void;
+    /**
+     * Reads an unsigned byte (0 to 255).
+     * @returns {number}
+     */
+    readByte(): number;
+    /**
+     * Writes an unsigned byte (0 to 255).
+     * @param {number} v
+     */
+    writeByte(v: number): void;
+    /**
+     * Reads a signed byte (-128 to 127).
+     * @returns {number}
+     */
+    readSignedByte(): number;
+    /**
+     * Writes a signed byte (-128 to 127).
+     * @param {number} v
+     */
+    writeSignedByte(v: number): void;
+    /**
+     * Reads a boolean (true or false).
+     * @returns {boolean}
+     */
+    readBoolean(): boolean;
+    /**
+     * Writes a boolean (true or false).
+     * @param {boolean} v
+     */
+    writeBoolean(v: boolean): void;
+    /**
+     * Reads a 16 bit (2 bytes) signed big-endian number.
+     * @returns {number}
+     */
+    readShort(): number;
+    /**
+     * Writes a 16 bit (2 bytes) signed big-endian number.
+     * @param {number} v
+     */
+    writeShort(v: number): void;
+    /**
+     * Reads a 16 bit (2 bytes) signed little-endian number.
+     * @returns {number}
+     */
+    readShortLE(): number;
+    /**
+     * Writes a 16 bit (2 bytes) signed little-endian number.
+     * @param {number} v
+     */
+    writeShortLE(v: number): void;
+    /**
+     * Reads a 16 bit (2 bytes) unsigned big-endian number.
+     * @returns {number}
+     */
+    readUnsignedShort(): number;
+    /**
+     * Writes a 16 bit (2 bytes) unsigned big-endian number.
+     * @param {number} v
+     */
+    writeUnsignedShort(v: number): void;
+    /**
+     * Reads a 16 bit (2 bytes) unsigned little-endian number.
+     * @returns {number}
+     */
+    readUnsignedShortLE(): number;
+    /**
+     * Writes a 16 bit (2 bytes) unsigned little-endian number.
+     * @param {number} v
+     */
+    writeUnsignedShortLE(v: number): void;
+    /**
+     * Reads a 24 bit (3 bytes) signed big-endian number.
+     * @returns {number}
+     */
+    readTriad(): number;
+    /**
+     * Writes a 24 bit (3 bytes) signed big-endian number.
+     * @param {number} v
+     */
+    writeTriad(v: number): void;
+    /**
+     * Reads a 24 bit (3 bytes) little-endian number.
+     * @returns {number}
+     */
+    readTriadLE(): number;
+    /**
+     * Writes a 24 bit (3 bytes) signed little-endian number.
+     * @param {number} v
+     */
+    writeTriadLE(v: number): void;
+    /**
+     * Reads a 24 bit (3 bytes) unsigned big-endian number.
+     * @returns {number}
+     */
+    readUnsignedTriad(): number;
+    /**
+     * Writes a 24 bit (3 bytes) unsigned big-endian number.
+     * @param {number} v
+     */
+    writeUnsignedTriad(v: number): void;
+    /**
+     * Reads a 24 bit (3 bytes) unsigned little-endian number.
+     * @returns {number}
+     */
+    readUnsignedTriadLE(): number;
+    /**
+     * Writes a 24 bit (3 bytes) unsigned little-endian number.
+     * @param {number} v
+     */
+    writeUnsignedTriadLE(v: number): void;
+    /**
+     * Reads a 32 bit (4 bytes) big-endian signed number.
+     * @returns {number}
+     */
+    readInt(): number;
+    /**
+     * Writes a 32 bit (4 bytes) big-endian signed number.
+     * @param {number} v
+     */
+    writeInt(v: number): void;
+    /**
+     * Reads a 32 bit (4 bytes) signed number.
+     * @returns {number}
+     */
+    readIntLE(): number;
+    /**
+     * Writes a 32 bit (4 bytes) little-endian signed number.
+     * @param {number} v
+     */
+    writeIntLE(v: number): void;
+    /**
+     * Reads a 32 bit (4 bytes) big-endian unsigned number.
+     * @returns {number}
+     */
+    readUnsignedInt(): number;
+    /**
+     * Writes a 32 bit (4 bytes) big-endian unsigned number.
+     * @param {number} v
+     */
+    writeUnsignedInt(v: number): void;
+    /**
+     * Reads a 32 bit (4 bytes) little-endian unsigned number.
+     * @returns {number}
+     */
+    readUnsignedIntLE(): number;
+    /**
+     * Writes a 32 bit (4 bytes) little-endian unsigned number.
+     * @param {number} v
+     */
+    writeUnsignedIntLE(v: number): void;
+    /**
+     * Returns a 32 bit (4 bytes) big-endian flating point number.
+     * @returns {number}
+     */
+    readFloat(): number;
+    /**
+     * Writes a 32 bit (4 bytes) big-endian floating point number.
+     * @param {number} v
+     */
+    writeFloat(v: number): void;
+    /**
+     * Returns a 32 bit (4 bytes) big-endian flating point number.
+     * @returns {number}
+     */
+    readFloatLE(): number;
+    /**
+     * Writes a 32 bit (4 bytes) little-endian floating point number.
+     * @param {number} v
+     */
+    writeFloatLE(v: number): void;
+    /**
+     * Returns a 64 bit (8 bytes) big-endian flating point number.
+     * @returns {number}
+     */
+    readDouble(): number;
+    /**
+     * Writes a 64 bit (8 bytes) big-endian floating point number.
+     * @param {number} v
+     */
+    writeDouble(v: number): void;
+    /**
+     * Returns a 64 bit (8 bytes) little-endian flating point number.
+     * @returns {number}
+     */
+    readDoubleLE(): number;
+    /**
+     * Writes a 64 bit (8 bytes) little-endian floating point number.
+     * @param {number} v
+     */
+    writeDoubleLE(v: number): void;
+    /**
+     * Returns a 64 bit (8 bytes) signed big-endian number.
+     * @returns {bigint}
+     */
+    readLong(): bigint;
+    /**
+     * Writes a 64 bit (8 bytes) signed big-endian number.
+     * @param {bigint} v
+     */
+    writeLong(v: bigint): void;
+    /**
+     * Returns a 64 bit (8 bytes) signed little-endian number.
+     * @returns {bigint}
+     */
+    readLongLE(): bigint;
+    /**
+     * Writes a 64 bit (8 bytes) signed little-endian number.
+     * @param {bigint} v
+     */
+    writeLongLE(v: bigint): void;
+    /**
+     * Returns a 64 bit (8 bytes) unsigned big-endian number.
+     * @returns {bigint}
+     */
+    readUnsignedLong(): bigint;
+    /**
+     * Writes a 64 bit (8 bytes) unsigned big-endian number.
+     * @param {bigint} v
+     */
+    writeUnsignedLong(v: bigint): void;
+    /**
+     * Returns a 64 bit (8 bytes) unsigned little-endian number.
+     * @returns {bigint}
+     */
+    readUnsignedLongLE(): bigint;
+    /**
+     * Writes a 64 bit (8 bytes) unsigned little-endian number.
+     * @param {bigint} v
+     */
+    writeUnsignedLongLE(v: bigint): void;
+    /**
+     * Reads a 32 bit (4 bytes) zigzag-encoded number.
+     * @returns {number}
+     */
+    readVarInt(): number;
+    /**
+     * Writes a 32 bit (4 bytes) zigzag-encoded number.
+     * @param {number} v
+     */
+    writeVarInt(v: number): void;
+    /**
+     * Reads a 32 bit unsigned number.
+     * @returns {number}
+     */
+    readUnsignedVarInt(): number;
+    /**
+     * Writes a 32 bit unsigned number with variable-length.
+     * @param {number} v
+     */
+    writeUnsignedVarInt(v: number): void;
+    /**
+     * Reads a 64 bit zigzag-encoded variable-length number.
+     * @returns {bigint}
+     */
+    readVarLong(): bigint;
+    /**
+     * Writes a 64 bit unsigned zigzag-encoded number.
+     * @param {bigint} v
+     */
+    writeVarLong(v: bigint): void;
+    /**
+     * Reads a 64 bit unsigned variable-length number.
+     * @returns {bigint}
+     */
+    readUnsignedVarLong(): bigint;
+    /**
+     * Writes a 64 bit unsigned variable-length number.
+     * @param {bigint} v
+     */
+    writeUnsignedVarLong(v: bigint): void;
+    /**
+     * Ensures write buffer has enough capacity, grows if needed.
+     * @param {number} needed
+     */
+    private ensureCapacity;
+    /**
+     * Grows the write buffer so that at least `capacity` bytes can be written without any
+     * further allocation, and returns this stream.
+     *
+     * Pre-sizing skips the 256 -> 512 -> 1024 ... growth ladder, each step of which copies the
+     * whole payload; a 3 KB packet starting from the 256-byte floor performs five allocations
+     * and memcpy's 1.25x its own size before it is done.
+     * @param {number} capacity
+     */
+    reserve(capacity: number): this;
+    /**
+     * Rewinds the write cursor while keeping the allocated capacity, so a long-lived encoder
+     * reaches a steady state where it never allocates again. This is the intended way to reuse
+     * a stream for many packets.
+     *
+     * Note the aliasing contract, which it shares with {@link clear} and {@link reuse}: any
+     * buffer previously handed out by {@link getWriteBuffer} is a *view* over this stream's
+     * memory and is invalidated by this call. Use {@link copyOut} or {@link copyInto} for
+     * output you intend to keep.
+     */
+    resetWrite(): void;
+    /**
+     * Returns the encoded bytes as an exactly-sized, standalone Buffer.
+     *
+     * Unlike {@link getWriteBuffer} the result does not alias this stream, so it survives
+     * {@link resetWrite}, and it does not pin a pool chunk: because `Buffer.allocUnsafe` is
+     * pool-backed (`Buffer.poolSize` is 64 KB on current Node), holding on to a handful of
+     * small slices from {@link getWriteBuffer} can keep megabytes alive.
+     * @returns {Buffer}
+     */
+    copyOut(): Buffer;
+    /**
+     * Copies the encoded bytes into a caller-owned buffer at `offset` and returns the offset
+     * just past them. Lets many packets be encoded into one arena with no per-packet
+     * allocation at all.
+     * @param {Buffer} target
+     * @param {number} offset
+     * @returns {number} the new offset
+     */
+    copyInto(target: Buffer, offset?: number): number;
+    /**
+     * Increases the write offset by the given length.
+     * @param {number} length
+     */
+    private addOffset;
+    /**
+     * Returns whatever or not the read offset is at end of line.
+     * @returns {number}
+     */
+    feof(): boolean;
+    /**
+     * Reads the remaining bytes and returns the buffer slice.
+     * @returns {Buffer}
+     */
+    readRemaining(): Buffer;
+    /**
+     * Skips len bytes on the buffer.
+     * @param {number} len
+     */
+    skip(len: number): void;
+    /**
+     * Returns the encoded buffer.
+     *
+     * Beware: when a read buffer is present this returns *that*, discarding everything
+     * written. On a stream used for both reading and writing it never returns your output.
+     * @returns {Buffer}
+     * @deprecated See {@link getReadBuffer} and {@link getWriteBuffer}.
+     */
+    getBuffer(): Buffer;
+    /**
+     * Returns the read buffer if available.
+     * @returns {Buffer}
+     */
+    getReadBuffer(): Buffer | null;
+    /**
+     * Returns the encoded bytes as a *view* over this stream's internal buffer.
+     *
+     * The view is only valid until the next write: {@link resetWrite}, {@link clear} and
+     * {@link reuse} all rewind the cursor without reallocating, so a previously returned
+     * buffer is silently overwritten by the next packet. If you queue the result - a send
+     * queue, a resend window - use {@link copyOut} or {@link copyInto} instead.
+     *
+     * It also keeps the whole pooled 64 KB chunk it was carved from alive; retaining a
+     * scattered handful of small packets this way can pin megabytes.
+     * @returns {Buffer}
+     */
+    getWriteBuffer(): Buffer;
+    /**
+     * Sets the buffer for reading.
+     * make sure to reset the reading index!
+     * @param buf - The new Buffer.
+     * @deprecated See {@link setReadBuffer} and {@link setWriteBuffer}.
+     */
+    setBuffer(buf: Buffer): void;
+    /**
+     * Sets the buffer for reading.
+     * @param buf - The new Buffer.
+     * @param rIndex - The new read index (default: 0, pass -1 to keep current).
+     */
+    setReadBuffer(buf: Buffer, rIndex?: number): void;
+    /**
+     * Sets the buffer for writing.
+     * @param buf - The new Buffer.
+     * @param wIndex - The new write index (default: 0, pass -1 to keep current).
+     */
+    setWriteBuffer(buf: Buffer, wIndex?: number): void;
+    /**
+     * Clears the whole BinaryStream instance.
+     *
+     * The write buffer and its capacity are kept, so any view previously returned by
+     * {@link getWriteBuffer} is invalidated. See {@link resetWrite}.
+     */
+    clear(): void;
+    /**
+     * Conventional method to reuse the stream
+     * without having to create a new BinaryStream instance.
+     *
+     * The write buffer and its capacity are kept, so any view previously returned by
+     * {@link getWriteBuffer} is invalidated. See {@link resetWrite}.
+     * @param buf - The new buffer instance.
+     */
+    reuse(buf: Buffer): void;
+    /**
+     * Sets the reading index.
+     * @param index - The new read index.
+     */
+    setReadIndex(index: number): void;
+    /**
+     * Sets the new writing index.
+     * @param index - The new write index.
+     */
+    setWriteIndex(index: number): void;
+    /**
+     * Retuns the read index.
+     * @returns {number}
+     */
+    getReadIndex(): number;
+    /**
+     * Returns the write index.
+     * @returns {number}
+     */
+    getWriteIndex(): number;
+    /**
+     * Do read assertions, check if the read buffer is null.
+     * @param {number} byteLength
+     */
+    private doReadAssertions;
+    /**
+     * Do read assertions, check if the read buffer is null.
+     * @param {number|bigint} num
+     * @param {number|bigint} minVal
+     * @param {number|bigint} maxVal
+     */
+    private doWriteAssertions;
+}
+export default BinaryStream;
+//# sourceMappingURL=BinaryStream.d.ts.map

package/dist/BinaryStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryStream.d.ts","sourceRoot":"","sources":["../src/BinaryStream.ts"],"names":[],"mappings":"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"}