apache-iggy 0.6.0 → 0.7.0

package/dist/wire/message/header.type.d.ts

@@ -17,6 +17,10 @@
  * under the License.
  */
 import { type ValueOf } from "../../type.utils.js";
+/**
+ * Enumeration of header value types supported in message headers.
+ * Each type maps to a numeric identifier for wire protocol encoding.
+ */
 export declare const HeaderKind: {
     readonly Raw: 1;
     readonly String: 2;
@@ -34,68 +38,106 @@ export declare const HeaderKind: {
     readonly Float: 14;
     readonly Double: 15;
 };
+/** Type alias for the HeaderKind object */
 export type HeaderKind = typeof HeaderKind;
+/** String literal type of header kind names */
 export type HeaderKindId = keyof HeaderKind;
+/** Numeric values of header kinds */
 export type HeaderKindValue = ValueOf<HeaderKind>;
+/** Reverse mapping from numeric value to header kind name */
 export declare const ReverseHeaderKind: Record<1 | 2 | 10 | 11 | 12 | 4 | 8 | 3 | 5 | 9 | 13 | 6 | 7 | 14 | 15, "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double">;
+/** Returns expected byte size for a header kind, or -1 for variable-size kinds */
+export declare const expectedSize: (kind: number) => number;
+/** Raw binary header value */
 export type HeaderValueRaw = {
-    kind: HeaderKind['Raw'];
+    kind: HeaderKind["Raw"];
     value: Buffer;
 };
+/** String header value */
 export type HeaderValueString = {
-    kind: HeaderKind['String'];
+    kind: HeaderKind["String"];
     value: string;
 };
+/** Boolean header value */
 export type HeaderValueBool = {
-    kind: HeaderKind['Bool'];
+    kind: HeaderKind["Bool"];
     value: boolean;
 };
+/** Signed 8-bit integer header value */
 export type HeaderValueInt8 = {
-    kind: HeaderKind['Int8'];
+    kind: HeaderKind["Int8"];
     value: number;
 };
+/** Signed 16-bit integer header value */
 export type HeaderValueInt16 = {
-    kind: HeaderKind['Int16'];
+    kind: HeaderKind["Int16"];
     value: number;
 };
+/** Signed 32-bit integer header value */
 export type HeaderValueInt32 = {
-    kind: HeaderKind['Int32'];
+    kind: HeaderKind["Int32"];
     value: number;
 };
+/** Signed 64-bit integer header value */
 export type HeaderValueInt64 = {
-    kind: HeaderKind['Int64'];
+    kind: HeaderKind["Int64"];
     value: bigint;
 };
+/** Signed 128-bit integer header value */
 export type HeaderValueInt128 = {
-    kind: HeaderKind['Int128'];
+    kind: HeaderKind["Int128"];
     value: Buffer;
 };
+/** Unsigned 8-bit integer header value */
 export type HeaderValueUint8 = {
-    kind: HeaderKind['Uint8'];
+    kind: HeaderKind["Uint8"];
     value: number;
 };
+/** Unsigned 16-bit integer header value */
 export type HeaderValueUint16 = {
-    kind: HeaderKind['Uint16'];
+    kind: HeaderKind["Uint16"];
     value: number;
 };
+/** Unsigned 32-bit integer header value */
 export type HeaderValueUint32 = {
-    kind: HeaderKind['Uint32'];
+    kind: HeaderKind["Uint32"];
     value: number;
 };
+/** Unsigned 64-bit integer header value */
 export type HeaderValueUint64 = {
-    kind: HeaderKind['Uint64'];
+    kind: HeaderKind["Uint64"];
     value: bigint;
 };
+/** Unsigned 128-bit integer header value */
 export type HeaderValueUint128 = {
-    kind: HeaderKind['Uint128'];
+    kind: HeaderKind["Uint128"];
     value: Buffer;
 };
+/** 32-bit floating point header value */
 export type HeaderValueFloat = {
-    kind: HeaderKind['Float'];
+    kind: HeaderKind["Float"];
     value: number;
 };
+/** 64-bit floating point (double) header value */
 export type HeaderValueDouble = {
-    kind: HeaderKind['Double'];
+    kind: HeaderKind["Double"];
+    value: number;
+};
+/** Header key with raw bytes */
+export type HeaderKeyRaw = {
+    kind: HeaderKind["Raw"];
+    value: Buffer;
+};
+/** Header key with string value */
+export type HeaderKeyString = {
+    kind: HeaderKind["String"];
+    value: string;
+};
+/** Header key with Int32 value */
+export type HeaderKeyInt32 = {
+    kind: HeaderKind["Int32"];
     value: number;
 };
+/** Union type of all possible header key types */
+export type HeaderKey = HeaderKeyRaw | HeaderKeyString | HeaderKeyInt32;
 //# sourceMappingURL=header.type.d.ts.map

package/dist/wire/message/header.type.js

@@ -17,6 +17,10 @@
  * under the License.
  */
 import { reverseRecord } from "../../type.utils.js";
+/**
+ * Enumeration of header value types supported in message headers.
+ * Each type maps to a numeric identifier for wire protocol encoding.
+ */
 export const HeaderKind = {
     Raw: 1,
     String: 2,
@@ -32,24 +36,33 @@ export const HeaderKind = {
     Uint64: 12,
     Uint128: 13,
     Float: 14,
-    Double: 15
+    Double: 15,
 };
+/** Reverse mapping from numeric value to header kind name */
 export const ReverseHeaderKind = reverseRecord(HeaderKind);
-// export type HeaderValue =
-//   HeaderValueRaw |
-//   HeaderValueString |
-//   HeaderValueBool |
-//   HeaderValueInt8 |
-//   HeaderValueInt16 |
-//   HeaderValueInt32 |
-//   HeaderValueInt64 |
-//   HeaderValueInt128 |
-//   HeaderValueUint8 |
-//   HeaderValueUint16 |
-//   HeaderValueUint32 |
-//   HeaderValueUint64 |
-//   HeaderValueUint128 |
-//   HeaderValueFloat |
-//   HeaderValueDouble;
-// export type Headers = Record<string, HeaderValue>;
+/** Returns expected byte size for a header kind, or -1 for variable-size kinds */
+export const expectedSize = (kind) => {
+    switch (kind) {
+        case HeaderKind.Bool:
+        case HeaderKind.Int8:
+        case HeaderKind.Uint8:
+            return 1;
+        case HeaderKind.Int16:
+        case HeaderKind.Uint16:
+            return 2;
+        case HeaderKind.Int32:
+        case HeaderKind.Uint32:
+        case HeaderKind.Float:
+            return 4;
+        case HeaderKind.Int64:
+        case HeaderKind.Uint64:
+        case HeaderKind.Double:
+            return 8;
+        case HeaderKind.Int128:
+        case HeaderKind.Uint128:
+            return 16;
+        default:
+            return -1;
+    }
+};
 //# sourceMappingURL=header.type.js.map

package/dist/wire/message/header.utils.d.ts

@@ -16,34 +16,123 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { type HeaderValueRaw, type HeaderValueString, type HeaderValueBool, type HeaderValueInt8, type HeaderValueInt16, type HeaderValueInt32, type HeaderValueInt64, type HeaderValueInt128, type HeaderValueUint8, type HeaderValueUint16, type HeaderValueUint32, type HeaderValueUint64, type HeaderValueUint128, type HeaderValueFloat, type HeaderValueDouble, type HeaderKindId } from './header.type.js';
+import { type HeaderValueRaw, type HeaderValueString, type HeaderValueBool, type HeaderValueInt8, type HeaderValueInt16, type HeaderValueInt32, type HeaderValueInt64, type HeaderValueInt128, type HeaderValueUint8, type HeaderValueUint16, type HeaderValueUint32, type HeaderValueUint64, type HeaderValueUint128, type HeaderValueFloat, type HeaderValueDouble, type HeaderKindId, type HeaderKey, type HeaderKeyRaw, type HeaderKeyString, type HeaderKeyInt32 } from "./header.type.js";
+/**
+ * Union type of all possible header value types.
+ */
 export type HeaderValue = HeaderValueRaw | HeaderValueString | HeaderValueBool | HeaderValueInt8 | HeaderValueInt16 | HeaderValueInt32 | HeaderValueInt64 | HeaderValueInt128 | HeaderValueUint8 | HeaderValueUint16 | HeaderValueUint32 | HeaderValueUint64 | HeaderValueUint128 | HeaderValueFloat | HeaderValueDouble;
-export type Headers = Record<string, HeaderValue>;
+/** Header entry with key and value */
+export type HeaderEntry = {
+    key: HeaderKey;
+    value: HeaderValue;
+};
+/** Array of header entries */
+export type Headers = HeaderEntry[];
+/**
+ * Internal representation of a header value in binary format.
+ */
 type BinaryHeaderValue = {
+    /** Header kind identifier */
     kind: number;
+    /** Serialized value as Buffer */
     value: Buffer;
 };
+/**
+ * Serializes a header value to a Buffer based on its kind.
+ *
+ * @param header - Header value to serialize
+ * @returns Serialized value as Buffer
+ */
 export declare const serializeHeaderValue: (header: HeaderValue) => Buffer<ArrayBufferLike>;
-export declare const serializeHeader: (key: string, v: BinaryHeaderValue) => Buffer<ArrayBuffer>;
+/**
+ * Serializes a header key to a Buffer based on its kind.
+ *
+ * @param key - Header key to serialize
+ * @returns Serialized key as Buffer
+ */
+export declare const serializeHeaderKey: (key: HeaderKey) => Buffer;
+/**
+ * Serializes a single header key-value pair to wire format.
+ * Format: [key_kind][key_length][key][value_kind][value_length][value]
+ *
+ * @param key - Header key
+ * @param v - Binary header value
+ * @returns Serialized header as Buffer
+ */
+export declare const serializeHeader: (key: HeaderKey, v: BinaryHeaderValue) => Buffer<ArrayBuffer>;
+/** Empty headers buffer constant */
 export declare const EMPTY_HEADERS: Buffer<ArrayBuffer>;
+/**
+ * Serializes all headers to a single buffer.
+ *
+ * @param headers - Optional headers array
+ * @returns Serialized headers buffer (empty if no headers)
+ */
 export declare const serializeHeaders: (headers?: Headers) => Buffer<ArrayBuffer>;
+/** Possible JavaScript types for deserialized header values */
 export type ParsedHeaderValue = boolean | string | number | bigint | Buffer;
-export type ParsedHeader = {
-    kind: ParsedHeaderValue;
+/** Deserialized header key with kind and value */
+export type ParsedHeaderKey = {
+    kind: number;
+    value: ParsedHeaderValue;
+};
+/** Deserialized header value with kind and value */
+export type ParsedHeaderVal = {
+    kind: number;
     value: ParsedHeaderValue;
 };
-type HeaderWithKey = ParsedHeader & {
-    key: string;
+/** Deserialized header entry */
+export type ParsedHeaderEntry = {
+    key: ParsedHeaderKey;
+    value: ParsedHeaderVal;
 };
-export type HeadersMap = Record<string, ParsedHeader>;
+/**
+ * Result of deserializing a single header.
+ */
 type ParsedHeaderDeserialized = {
+    /** Number of bytes consumed */
     bytesRead: number;
-    data: HeaderWithKey;
+    /** Deserialized header entry */
+    data: ParsedHeaderEntry;
 };
+/**
+ * Maps a numeric header kind to its string identifier.
+ *
+ * @param k - Numeric header kind value
+ * @returns Header kind identifier string
+ * @throws Error if the header kind is unknown
+ */
 export declare const mapHeaderKind: (k: number) => HeaderKindId;
+/**
+ * Deserializes a header value buffer based on its kind.
+ *
+ * @param kind - Numeric header kind
+ * @param value - Raw value buffer
+ * @returns Deserialized value
+ * @throws Error if the header kind is invalid
+ */
 export declare const deserializeHeaderValue: (kind: number, value: Buffer) => ParsedHeaderValue;
+/**
+ * Deserializes a single header from a buffer.
+ * Format: [key_kind][key_length][key][value_kind][value_length][value]
+ *
+ * @param p - Buffer containing serialized headers
+ * @param pos - Starting position in the buffer
+ * @returns Object with bytes read and deserialized header data
+ * @throws Error if header key or value length is invalid (must be 1-255)
+ */
 export declare const deserializeHeader: (p: Buffer, pos?: number) => ParsedHeaderDeserialized;
-export declare const deserializeHeaders: (p: Buffer, pos?: number) => HeadersMap;
+/**
+ * Deserializes all headers from a buffer.
+ *
+ * @param p - Buffer containing serialized headers
+ * @param pos - Starting position in the buffer
+ * @returns Array of parsed header entries
+ */
+export declare const deserializeHeaders: (p: Buffer, pos?: number) => ParsedHeaderEntry[];
+/**
+ * HeaderValue factory object with constructors for all header types.
+ */
 export declare const HeaderValue: {
     Raw: (value: Buffer) => HeaderValueRaw;
     String: (value: string) => HeaderValueString;
@@ -63,5 +152,10 @@ export declare const HeaderValue: {
     getKind: (h: HeaderValue) => "Raw" | "String" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "Int128" | "Uint8" | "Uint16" | "Uint32" | "Uint64" | "Uint128" | "Float" | "Double";
     getValue: (h: HeaderValue) => string | number | bigint | boolean | Buffer<ArrayBufferLike>;
 };
+export declare const HeaderKeyFactory: {
+    Raw: (value: Buffer) => HeaderKeyRaw;
+    String: (value: string) => HeaderKeyString;
+    Int32: (value: number) => HeaderKeyInt32;
+};
 export {};
 //# sourceMappingURL=header.utils.d.ts.map