@sachitv/avro-typescript 0.4.0

package/esm/serialization/streams/stream_writable_buffer.js

@@ -0,0 +1,64 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StreamWritableBuffer_writer;
+/**
+ * A writable buffer implementation that writes data sequentially to a WritableStream.
+ * This provides streaming write capabilities for large data outputs.
+ *
+ * Key features:
+ * - Stream-backed: Writes data sequentially to a WritableStream.
+ * - Memory efficient: Processes data in chunks without buffering everything in memory.
+ * - Web standard: Uses the Web Streams API for broad compatibility.
+ *
+ * @example
+ * ```typescript
+ * const stream = new WritableStream({
+ *   write(chunk) {
+ *     // Handle chunk
+ *   }
+ * });
+ * const buffer = new StreamWritableBuffer(stream);
+ *
+ * await buffer.writeBytes(new Uint8Array([1, 2, 3, 4]));
+ * await buffer.close();
+ * ```
+ */
+export class StreamWritableBuffer {
+    /**
+     * Creates a new StreamWritableBuffer from the provided WritableStream.
+     *
+     * @param stream The WritableStream to write data to.
+     */
+    constructor(stream) {
+        _StreamWritableBuffer_writer.set(this, void 0);
+        __classPrivateFieldSet(this, _StreamWritableBuffer_writer, stream.getWriter(), "f");
+    }
+    /**
+     * Writes bytes to the stream.
+     *
+     * @param data The bytes to write.
+     */
+    async writeBytes(data) {
+        if (data.length === 0) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _StreamWritableBuffer_writer, "f").write(data);
+    }
+    /**
+     * Closes the stream and releases the writer lock.
+     */
+    async close() {
+        await __classPrivateFieldGet(this, _StreamWritableBuffer_writer, "f").close();
+        __classPrivateFieldGet(this, _StreamWritableBuffer_writer, "f").releaseLock();
+    }
+}
+_StreamWritableBuffer_writer = new WeakMap();

package/esm/serialization/streams/stream_writable_buffer_adapter.d.ts

@@ -0,0 +1,36 @@
+import type { IWritableBuffer } from "../buffers/buffer.js";
+import type { IStreamWritableBuffer } from "./streams.js";
+/**
+ * Adapter that wraps an IStreamWritableBuffer to provide IWritableBuffer interface.
+ * This collects writes and forwards them to the stream buffer.
+ */
+export declare class StreamWritableBufferAdapter implements IWritableBuffer {
+    #private;
+    /**
+     * Creates a new adapter from a stream writable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer: IStreamWritableBuffer);
+    /**
+     * Appends bytes to the buffer, advancing its internal write cursor when the
+     * operation succeeds.
+     */
+    appendBytes(data: Uint8Array): Promise<void>;
+    /**
+     * Returns whether the buffer can continue accepting writes.
+     * Stream buffers can always accept writes until explicitly closed.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    canAppendMore(_size: number): Promise<boolean>;
+    /**
+     * Closes the underlying stream buffer.
+     * After calling this, further writes will be ignored.
+     */
+    close(): Promise<void>;
+}

package/esm/serialization/streams/stream_writable_buffer_adapter.js

@@ -0,0 +1,65 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StreamWritableBufferAdapter_streamBuffer, _StreamWritableBufferAdapter_isClosed;
+/**
+ * Adapter that wraps an IStreamWritableBuffer to provide IWritableBuffer interface.
+ * This collects writes and forwards them to the stream buffer.
+ */
+export class StreamWritableBufferAdapter {
+    /**
+     * Creates a new adapter from a stream writable buffer.
+     *
+     * @param streamBuffer The stream buffer to adapt.
+     */
+    constructor(streamBuffer) {
+        _StreamWritableBufferAdapter_streamBuffer.set(this, void 0);
+        _StreamWritableBufferAdapter_isClosed.set(this, false);
+        __classPrivateFieldSet(this, _StreamWritableBufferAdapter_streamBuffer, streamBuffer, "f");
+    }
+    /**
+     * Appends bytes to the buffer, advancing its internal write cursor when the
+     * operation succeeds.
+     */
+    async appendBytes(data) {
+        if (__classPrivateFieldGet(this, _StreamWritableBufferAdapter_isClosed, "f")) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _StreamWritableBufferAdapter_streamBuffer, "f").writeBytes(data);
+    }
+    /**
+     * Returns whether the buffer can continue accepting writes.
+     * Stream buffers can always accept writes until explicitly closed.
+     */
+    // deno-lint-ignore require-await
+    async isValid() {
+        return !__classPrivateFieldGet(this, _StreamWritableBufferAdapter_isClosed, "f");
+    }
+    /**
+     * Checks if the buffer can accept appending the given number of bytes.
+     * @param size The number of bytes to check.
+     * @returns True if the buffer can accept the append.
+     */
+    async canAppendMore(_size) {
+        return await this.isValid();
+    }
+    /**
+     * Closes the underlying stream buffer.
+     * After calling this, further writes will be ignored.
+     */
+    async close() {
+        if (!__classPrivateFieldGet(this, _StreamWritableBufferAdapter_isClosed, "f")) {
+            __classPrivateFieldSet(this, _StreamWritableBufferAdapter_isClosed, true, "f");
+            await __classPrivateFieldGet(this, _StreamWritableBufferAdapter_streamBuffer, "f").close();
+        }
+    }
+}
+_StreamWritableBufferAdapter_streamBuffer = new WeakMap(), _StreamWritableBufferAdapter_isClosed = new WeakMap();

package/esm/serialization/streams/streams.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Interface describing a readable buffer backed by a ReadableStream.
+ * This provides sequential reading capabilities.
+ */
+export interface IStreamReadableBuffer {
+    /**
+     * Reads the next chunk of data from the stream.
+     * @returns A Promise that resolves to the next Uint8Array chunk, or undefined if the stream is exhausted.
+     */
+    readNext(): Promise<Uint8Array | undefined>;
+    /**
+     * Closes the stream and releases the reader lock.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Interface describing a writable buffer backed by a WritableStream.
+ * This provides sequential writing capabilities.
+ */
+export interface IStreamWritableBuffer {
+    /**
+     * Writes bytes to the stream.
+     */
+    writeBytes(data: Uint8Array): Promise<void>;
+    /**
+     * Closes the stream.
+     */
+    close(): Promise<void>;
+}

package/esm/serialization/streams/streams.js

@@ -0,0 +1 @@
+export {};

package/esm/serialization/tap.d.ts

@@ -0,0 +1,427 @@
+import type { IReadableBuffer, IWritableBuffer } from "./buffers/buffer.js";
+/**
+ * Interface for readable tap operations in Avro serialization.
+ */
+export interface ReadableTapLike {
+    /**
+     * Returns whether the cursor is positioned within the buffer bounds.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * Returns whether more data can be read from the current position without advancing the cursor.
+     */
+    canReadMore(): Promise<boolean>;
+    /**
+     * Returns the buffer contents from the start up to the current cursor.
+     * @throws RangeError if the cursor has advanced past the buffer length.
+     */
+    getValue(): Promise<Uint8Array>;
+    /**
+     * Reads the next byte as a boolean value and advances the cursor by one byte.
+     */
+    readBoolean(): Promise<boolean>;
+    /**
+     * Skips a boolean value by advancing the cursor by one byte.
+     */
+    skipBoolean(): void;
+    /**
+     * Reads a variable-length zig-zag encoded 32-bit signed integer.
+     */
+    readInt(): Promise<number>;
+    /**
+     * Reads a variable-length zig-zag encoded 64-bit signed integer as bigint.
+     */
+    readLong(): Promise<bigint>;
+    /**
+     * Skips a zig-zag encoded 32-bit integer by delegating to `skipLong`.
+     */
+    skipInt(): Promise<void>;
+    /**
+     * Skips a zig-zag encoded 64-bit integer, advancing past continuation bytes.
+     */
+    skipLong(): Promise<void>;
+    /**
+     * Reads a 32-bit little-endian floating point number.
+     * @throws RangeError if the read would exceed the buffer.
+     */
+    readFloat(): Promise<number>;
+    /**
+     * Skips a 32-bit floating point value by advancing four bytes.
+     */
+    skipFloat(): void;
+    /**
+     * Reads a 64-bit little-endian floating point number.
+     * @throws RangeError if the read would exceed the buffer.
+     */
+    readDouble(): Promise<number>;
+    /**
+     * Skips a 64-bit floating point value by advancing eight bytes.
+     */
+    skipDouble(): void;
+    /**
+     * Reads a fixed-length byte sequence into a new buffer.
+     * @param len Number of bytes to read.
+     * @throws RangeError if the read exceeds the buffer.
+     */
+    readFixed(len: number): Promise<Uint8Array>;
+    /**
+     * Skips a fixed-length byte sequence.
+     * @param len Number of bytes to skip.
+     */
+    skipFixed(len: number): void;
+    /**
+     * Reads a length-prefixed byte sequence.
+     * @throws RangeError if insufficient data remains.
+     */
+    readBytes(): Promise<Uint8Array>;
+    /**
+     * Skips a length-prefixed byte sequence.
+     */
+    skipBytes(): Promise<void>;
+    /**
+     * Reads a length-prefixed UTF-8 string.
+     * @throws RangeError when the buffer is exhausted prematurely.
+     */
+    readString(): Promise<string>;
+    /**
+     * Skips a length-prefixed UTF-8 string.
+     */
+    skipString(): Promise<void>;
+    /**
+     * Compares the next boolean value with the one from another tap.
+     * @param tap Tap to compare against; both cursors advance.
+     * @returns 0 when equal, negative when this tap's value is false and the other true, positive otherwise.
+     */
+    matchBoolean(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next zig-zag encoded 32-bit integer with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchInt(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next zig-zag encoded 64-bit integer with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchLong(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next 32-bit float value with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchFloat(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next 64-bit float value with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchDouble(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares fixed-length byte sequences from this tap and another tap.
+     * @param tap Tap to compare against; both cursors advance by `len`.
+     * @param len Number of bytes to compare.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchFixed(tap: ReadableTapLike, len: number): Promise<number>;
+    /**
+     * Compares length-prefixed byte sequences from this tap and another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchBytes(tap: ReadableTapLike): Promise<number>;
+    /** Matches a string value. */
+    matchString(tap: ReadableTapLike): Promise<number>;
+    /** Unpacks a long-encoded byte array. */
+    unpackLongBytes(): Promise<Uint8Array>;
+}
+/**
+ * Interface for writable tap operations compatible with Avro binary serialization.
+ */
+export interface WritableTapLike {
+    /**
+     * Returns whether the tap is valid for writing.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * Writes a boolean value as a single byte.
+     * @param value The boolean value to write.
+     */
+    writeBoolean(value: boolean): Promise<void>;
+    /**
+     * Writes a zig-zag encoded 32-bit signed integer.
+     * @param value The integer value to write.
+     */
+    writeInt(value: number): Promise<void>;
+    /**
+     * Writes a zig-zag encoded 64-bit signed integer.
+     * @param value The bigint value to write.
+     */
+    writeLong(value: bigint): Promise<void>;
+    /**
+     * Writes a 32-bit little-endian floating point number.
+     * @param value The float value to write.
+     */
+    writeFloat(value: number): Promise<void>;
+    /**
+     * Writes a 64-bit little-endian floating point number.
+     * @param value The double value to write.
+     */
+    writeDouble(value: number): Promise<void>;
+    /**
+     * Writes a fixed-length byte sequence from the provided buffer.
+     * @param buf Source buffer to copy from.
+     * @param len Optional number of bytes to write; defaults to the buffer length.
+     */
+    writeFixed(buf: Uint8Array, len?: number): Promise<void>;
+    /**
+     * Writes a length-prefixed byte sequence backed by the provided buffer.
+     * @param buf The bytes to write.
+     */
+    writeBytes(buf: Uint8Array): Promise<void>;
+    /**
+     * Writes a length-prefixed UTF-8 string.
+     * @param str The string to encode and write.
+     */
+    writeString(str: string): Promise<void>;
+    /**
+     * Writes a binary string as raw bytes without a length prefix.
+     * @param str Source string containing binary data.
+     * @param len Number of bytes from the string to write.
+     */
+    writeBinary(str: string, len: number): Promise<void>;
+    /**
+     * Encodes an 8-byte two's complement integer into zig-zag encoded varint bytes.
+     * @param arr Buffer containing the 8-byte value to encode; reused during processing.
+     */
+    packLongBytes(arr: Uint8Array): Promise<void>;
+}
+/** Abstract base class for tap implementations that manage buffer position. */
+export declare abstract class TapBase {
+    /** The current position in the buffer. */
+    protected pos: number;
+    /** Initializes the tap with the given position. */
+    protected constructor(pos: number);
+    /**
+     * Returns the current cursor position within the buffer.
+     */
+    getPos(): number;
+    /**
+     * Resets the cursor to the beginning of the buffer.
+     */
+    _testOnlyResetPos(): void;
+}
+/**
+ * Binary tap that exposes Avro-compatible read helpers on top of a readable buffer.
+ */
+export declare class ReadableTap extends TapBase implements ReadableTapLike {
+    #private;
+    /** The readable buffer backing this tap. */
+    protected readonly buffer: IReadableBuffer;
+    /** Creates a new ReadableTap with the given buffer and initial position. */
+    constructor(buf: ArrayBuffer | IReadableBuffer, pos?: number);
+    /**
+     * Returns whether the cursor is positioned within the buffer bounds.
+     */
+    isValid(): Promise<boolean>;
+    /**
+     * Returns whether more data can be read from the current position without advancing the cursor.
+     */
+    canReadMore(): Promise<boolean>;
+    /**
+     * Returns a defensive copy of the current buffer for testing purposes.
+     */
+    _testOnlyBuf(): Promise<Uint8Array>;
+    /**
+     * Returns the buffer contents from the start up to the current cursor.
+     * @throws RangeError if the cursor has advanced past the buffer length.
+     */
+    getValue(): Promise<Uint8Array>;
+    /** Retrieves the byte at the specified position in the buffer. */
+    private getByteAt;
+    /**
+     * Reads the next byte as a boolean value and advances the cursor by one byte.
+     */
+    readBoolean(): Promise<boolean>;
+    /**
+     * Skips a boolean value by advancing the cursor by one byte.
+     */
+    skipBoolean(): void;
+    /**
+     * Reads a variable-length zig-zag encoded 32-bit signed integer.
+     */
+    readInt(): Promise<number>;
+    /**
+     * Reads a variable-length zig-zag encoded 64-bit signed integer as bigint.
+     */
+    readLong(): Promise<bigint>;
+    /**
+     * Skips a zig-zag encoded 32-bit integer by delegating to `skipLong`.
+     */
+    skipInt(): Promise<void>;
+    /**
+     * Skips a zig-zag encoded 64-bit integer, advancing past continuation bytes.
+     */
+    skipLong(): Promise<void>;
+    /**
+     * Reads a 32-bit little-endian floating point number.
+     * @throws RangeError if the read would exceed the buffer.
+     */
+    readFloat(): Promise<number>;
+    /**
+     * Skips a 32-bit floating point value by advancing four bytes.
+     */
+    skipFloat(): void;
+    /**
+     * Reads a 64-bit little-endian floating point number.
+     * @throws RangeError if the read would exceed the buffer.
+     */
+    readDouble(): Promise<number>;
+    /**
+     * Skips a 64-bit floating point value by advancing eight bytes.
+     */
+    skipDouble(): void;
+    /**
+     * Reads a fixed-length byte sequence into a new buffer.
+     * @param len Number of bytes to read.
+     * @throws RangeError if the read exceeds the buffer.
+     */
+    readFixed(len: number): Promise<Uint8Array>;
+    /**
+     * Skips a fixed-length byte sequence.
+     * @param len Number of bytes to skip.
+     */
+    skipFixed(len: number): void;
+    /**
+     * Reads a length-prefixed byte sequence.
+     * @throws RangeError if insufficient data remains.
+     */
+    readBytes(): Promise<Uint8Array>;
+    /**
+     * Skips a length-prefixed byte sequence.
+     */
+    skipBytes(): Promise<void>;
+    /**
+     * Skips a length-prefixed UTF-8 string.
+     */
+    skipString(): Promise<void>;
+    /**
+     * Reads a length-prefixed UTF-8 string.
+     * @throws RangeError when the buffer is exhausted prematurely.
+     */
+    readString(): Promise<string>;
+    /**
+     * Compares the next boolean value with the one from another tap.
+     * @param tap Tap to compare against; both cursors advance.
+     * @returns 0 when equal, negative when this tap's value is false and the other true, positive otherwise.
+     */
+    matchBoolean(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next zig-zag encoded 32-bit integer with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchInt(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next zig-zag encoded 64-bit integer with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchLong(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next 32-bit float value with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchFloat(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares the next 64-bit float value with another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchDouble(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares fixed-length byte sequences from this tap and another tap.
+     * @param tap Tap to compare against; both cursors advance by `len`.
+     * @param len Number of bytes to compare.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchFixed(tap: ReadableTapLike, len: number): Promise<number>;
+    /**
+     * Compares length-prefixed byte sequences from this tap and another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchBytes(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Compares length-prefixed UTF-8 strings read from this tap and another tap.
+     * @returns Comparison result using -1/0/1 semantics.
+     */
+    matchString(tap: ReadableTapLike): Promise<number>;
+    /**
+     * Decodes the next zig-zag encoded long into an 8-byte two's complement buffer.
+     */
+    unpackLongBytes(): Promise<Uint8Array>;
+}
+/**
+ * Binary tap that exposes Avro-compatible write helpers on top of a writable buffer.
+ */
+export declare class WritableTap extends TapBase implements WritableTapLike {
+    /** The writable buffer backing this tap. */
+    private readonly buffer;
+    /**
+     * Creates a new WritableTap instance.
+     * @param buf The buffer to write to, either an ArrayBuffer or IWritableBuffer.
+     * @param pos The initial position in the buffer (default 0).
+     */
+    constructor(buf: ArrayBuffer | IWritableBuffer, pos?: number);
+    /**
+     * Appends raw bytes to the buffer and advances the cursor.
+     * @param bytes The bytes to append.
+     */
+    private appendRawBytes;
+    /** Checks if the buffer is valid. */
+    isValid(): Promise<boolean>;
+    /**
+     * Writes a boolean value as a single byte and advances the cursor.
+     * @param value Boolean value to write.
+     */
+    writeBoolean(value: boolean): Promise<void>;
+    /**
+     * Writes a zig-zag encoded 32-bit signed integer.
+     * @param n Integer value to write.
+     */
+    writeInt(n: number): Promise<void>;
+    /**
+     * Writes a zig-zag encoded 64-bit signed integer.
+     * @param value BigInt value to write.
+     */
+    writeLong(value: bigint): Promise<void>;
+    /**
+     * Writes a 32-bit little-endian floating point number.
+     * @param value Float to write.
+     */
+    writeFloat(value: number): Promise<void>;
+    /**
+     * Writes a 64-bit little-endian floating point number.
+     * @param value Double precision value to write.
+     */
+    writeDouble(value: number): Promise<void>;
+    /**
+     * Writes a fixed-length byte sequence from the provided buffer.
+     * @param buf Source buffer to copy from.
+     * @param len Optional number of bytes to write; defaults to the buffer length.
+     */
+    writeFixed(buf: Uint8Array, len?: number): Promise<void>;
+    /**
+     * Writes a length-prefixed byte sequence backed by the provided buffer.
+     * @param buf Bytes to write.
+     */
+    writeBytes(buf: Uint8Array): Promise<void>;
+    /**
+     * Writes a length-prefixed UTF-8 string.
+     * @param str String to encode and write.
+     */
+    writeString(str: string): Promise<void>;
+    /**
+     * Writes a binary string as raw bytes without a length prefix.
+     * @param str Source string containing binary data.
+     * @param len Number of bytes from the string to write.
+     */
+    writeBinary(str: string, len: number): Promise<void>;
+    /**
+     * Encodes an 8-byte two's complement integer into zig-zag encoded varint bytes.
+     * @param arr Buffer containing the 8-byte value to encode; reused during processing.
+     */
+    packLongBytes(arr: Uint8Array): Promise<void>;
+}