clean up and formatting

Author: nicknisi

src/common/utils/leb128.spec.ts

@@ -77,19 +77,25 @@ describe('leb128', () => {
       });
 
       test('throws for numbers > MAX_UINT32', () => {
-        expect(() => encodeUInt32(4294967296)).toThrow('Value must not exceed 4294967295');
+        expect(() => encodeUInt32(4294967296)).toThrow(
+          'Value must not exceed 4294967295',
+        );
       });
 
       test('throws for non-integers', () => {
         expect(() => encodeUInt32(3.14)).toThrow('Value must be an integer');
       });
 
       test('throws for NaN', () => {
-        expect(() => encodeUInt32(NaN)).toThrow('Value must be a finite number');
+        expect(() => encodeUInt32(NaN)).toThrow(
+          'Value must be a finite number',
+        );
       });
 
       test('throws for Infinity', () => {
-        expect(() => encodeUInt32(Infinity)).toThrow('Value must be a finite number');
+        expect(() => encodeUInt32(Infinity)).toThrow(
+          'Value must be a finite number',
+        );
       });
     });
   });
@@ -205,12 +211,16 @@ describe('leb128', () => {
     describe('invalid inputs', () => {
       test('throws for offset beyond buffer bounds', () => {
         const data = new Uint8Array([0x2a]);
-        expect(() => decodeUInt32(data, 5)).toThrow('Offset 5 is out of bounds');
+        expect(() => decodeUInt32(data, 5)).toThrow(
+          'Offset 5 is out of bounds',
+        );
       });
 
       test('throws for negative offset', () => {
         const data = new Uint8Array([0x2a]);
-        expect(() => decodeUInt32(data, -1)).toThrow('Offset -1 is out of bounds');
+        expect(() => decodeUInt32(data, -1)).toThrow(
+          'Offset -1 is out of bounds',
+        );
       });
 
       test('throws for truncated encoding (incomplete byte sequence)', () => {
@@ -228,7 +238,9 @@ describe('leb128', () => {
       test('throws for encoding that exceeds uint32 range', () => {
         // 6 bytes with continuation bits (should never happen for uint32)
         const data = new Uint8Array([0x80, 0x80, 0x80, 0x80, 0x80, 0x01]);
-        expect(() => decodeUInt32(data)).toThrow('LEB128 sequence exceeds maximum length for uint32');
+        expect(() => decodeUInt32(data)).toThrow(
+          'LEB128 sequence exceeds maximum length for uint32',
+        );
       });
     });
   });

src/common/utils/leb128.ts

@@ -1,38 +1,23 @@
 /**
- * LEB128 (Little Endian Base 128) encoding/decoding for unsigned 32-bit integers.
- *
- * This is a variable-length integer encoding where each byte stores 7 bits of data
- * and uses bit 7 as a continuation flag (1 = more bytes follow, 0 = last byte).
- *
- * Benefits:
- * - Small values use fewer bytes (e.g., 0-127 use only 1 byte)
- * - Works in all JavaScript runtimes (uses only Uint8Array)
- * - No dependencies on Node.js Buffer or other runtime-specific APIs
+ * LEB128 (Little Endian Base 128) encoding for unsigned 32-bit integers.
+ * Variable-length encoding: each byte stores 7 bits of data, bit 7 is continuation flag.
  */
 
 const MAX_UINT32 = 0xffffffff;
 const CONTINUATION_BIT = 0x80;
 const DATA_BITS_MASK = 0x7f;
 const DATA_BITS_PER_BYTE = 7;
-const MAX_BYTES_FOR_UINT32 = 5; // ceil(32 / 7) = 5
+const MAX_BYTES_FOR_UINT32 = 5;
 
 /**
  * Encodes an unsigned 32-bit integer into LEB128 format.
  *
- * @param value - The unsigned 32-bit integer to encode (0 to 4,294,967,295)
- * @returns Uint8Array containing the encoded bytes (1-5 bytes)
- * @throws Error if value is invalid
- *
- * @example
- * encodeUInt32(0) // Uint8Array[0x00] (1 byte)
- * encodeUInt32(127) // Uint8Array[0x7F] (1 byte)
- * encodeUInt32(128) // Uint8Array[0x80, 0x01] (2 bytes)
- * encodeUInt32(300) // Uint8Array[0xAC, 0x02] (2 bytes)
+ * @param value - Unsigned 32-bit integer (0 to 4,294,967,295)
+ * @returns Encoded bytes (1-5 bytes depending on value)
  */
 export function encodeUInt32(value: number): Uint8Array {
   validateUInt32(value);
 
-  // Handle zero directly (most common small value)
   if (value === 0) {
     return new Uint8Array([0]);
   }
@@ -56,16 +41,9 @@ export function encodeUInt32(value: number): Uint8Array {
 /**
  * Decodes an unsigned 32-bit integer from LEB128 format.
  *
- * @param data - Uint8Array containing LEB128 encoded data
- * @param offset - Starting position in the buffer (defaults to 0)
- * @returns Object with decoded value and the index after the last byte read
- * @throws Error if decoding fails
- *
- * @example
- * decodeUInt32(new Uint8Array([0x00])) // { value: 0, nextIndex: 1 }
- * decodeUInt32(new Uint8Array([0x7F])) // { value: 127, nextIndex: 1 }
- * decodeUInt32(new Uint8Array([0x80, 0x01])) // { value: 128, nextIndex: 2 }
- * decodeUInt32(new Uint8Array([0xAC, 0x02])) // { value: 300, nextIndex: 2 }
+ * @param data - Buffer containing LEB128 encoded data
+ * @param offset - Starting position in buffer (default: 0)
+ * @returns Decoded value and index after last byte read
  */
 export function decodeUInt32(
   data: Uint8Array,
@@ -82,15 +60,13 @@ export function decodeUInt32(
     const byte = data[index++];
     bytesRead++;
 
-    // Check for overflow before processing
     if (bytesRead > MAX_BYTES_FOR_UINT32) {
       throw new Error('LEB128 sequence exceeds maximum length for uint32');
     }
 
     result |= (byte & DATA_BITS_MASK) << shift;
 
     if (!hasContinuationBit(byte)) {
-      // Convert to unsigned 32-bit integer
       return { value: result >>> 0, nextIndex: index };
     }
 
@@ -100,9 +76,6 @@ export function decodeUInt32(
   throw new Error('Truncated LEB128 encoding');
 }
 
-/**
- * Validates that a value is a valid unsigned 32-bit integer.
- */
 function validateUInt32(value: number): void {
   if (!Number.isFinite(value)) {
     throw new Error('Value must be a finite number');
@@ -118,18 +91,14 @@ function validateUInt32(value: number): void {
   }
 }
 
-/**
- * Validates that an offset is within bounds.
- */
 function validateOffset(data: Uint8Array, offset: number): void {
   if (offset < 0 || offset >= data.length) {
-    throw new Error(`Offset ${offset} is out of bounds (buffer length: ${data.length})`);
+    throw new Error(
+      `Offset ${offset} is out of bounds (buffer length: ${data.length})`,
+    );
   }
 }
 
-/**
- * Checks if a byte has the continuation bit set.
- */
 function hasContinuationBit(byte: number): boolean {
   return (byte & CONTINUATION_BIT) !== 0;
-}
+}

src/common/utils/query-string.ts

@@ -1,82 +1,57 @@
-/**
- * Native query string serialization that replaces the qs library.
- * Maintains backward compatibility with existing URL formatting.
- *
- * This implementation:
- * - Uses only native Web APIs (works in all runtimes)
- * - Handles arrays with 'repeat' format: scope=read&scope=write
- * - Sorts keys alphabetically for consistency
- * - Uses RFC1738 encoding (space as +)
- * - Handles nested objects: provider_query_params[key]=value
- * - Filters out undefined values
- */
-
-type QueryValue = string | string[] | Record<string, string | boolean | number> | undefined;
+type QueryValue =
+  | string
+  | string[]
+  | Record<string, string | boolean | number>
+  | undefined;
 
 /**
- * Converts an options object to a query string.
- * Compatible with the qs library's stringify method when used with:
- * - arrayFormat: 'repeat'
- * - format: 'RFC1738'
- * - sort: alphabetical
+ * Converts options to a query string.
+ * - Arrays: scope=read&scope=write (repeat format)
+ * - Objects: params[key]=value (bracket notation)
+ * - Encoding: RFC1738 (space as +)
+ * - Keys sorted alphabetically
  */
 export function toQueryString(options: Record<string, QueryValue>): string {
   const params: Array<[string, string]> = [];
-
-  // Get sorted keys for consistent output (matches qs behavior)
   const sortedKeys = Object.keys(options).sort((a, b) => a.localeCompare(b));
 
   for (const key of sortedKeys) {
     const value = options[key];
 
-    // Skip undefined values (matches qs behavior)
     if (value === undefined) {
       continue;
     }
 
-    // Handle arrays with 'repeat' format: key=val1&key=val2
     if (Array.isArray(value)) {
       for (const item of value) {
         params.push([key, String(item)]);
       }
-    }
-    // Handle nested objects: key[subkey]=value
-    else if (typeof value === 'object' && value !== null) {
-      const sortedSubKeys = Object.keys(value).sort((a, b) => a.localeCompare(b));
+    } else if (typeof value === 'object' && value !== null) {
+      const sortedSubKeys = Object.keys(value).sort((a, b) =>
+        a.localeCompare(b),
+      );
       for (const subKey of sortedSubKeys) {
         const subValue = value[subKey];
         if (subValue !== undefined) {
           params.push([`${key}[${subKey}]`, String(subValue)]);
         }
       }
-    }
-    // Handle primitives (string, number, boolean)
-    else {
+    } else {
       params.push([key, String(value)]);
     }
   }
 
-  // Build query string with RFC1738 encoding (space as +)
   return params
     .map(([key, value]) => {
-      // Encode using RFC1738 format (matches qs behavior)
       const encodedKey = encodeRFC1738(key);
       const encodedValue = encodeRFC1738(value);
       return `${encodedKey}=${encodedValue}`;
     })
     .join('&');
 }
 
-/**
- * Encodes a string using RFC1738 format.
- * - Space is encoded as +
- * - Additional characters encoded to match qs library behavior
- */
 function encodeRFC1738(str: string): string {
   return encodeURIComponent(str)
-    .replace(/%20/g, '+')        // Space as + (RFC1738)
-    .replace(/[!'*]/g, (c) => {
-      // Encode additional characters to match qs behavior
-      return '%' + c.charCodeAt(0).toString(16).toUpperCase();
-    });
+    .replace(/%20/g, '+')
+    .replace(/[!'*]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase());
 }