chore(internal): refactor utils

Author: stainless-app[bot]

src/client.ts

@@ -652,12 +652,12 @@ export class OpenAI {
       fetchOptions.method = method.toUpperCase();
     }
 
-    return (
+    try {
       // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-      this.fetch.call(undefined, url, fetchOptions).finally(() => {
-        clearTimeout(timeout);
-      })
-    );
+      return await this.fetch.call(undefined, url, fetchOptions);
+    } finally {
+      clearTimeout(timeout);
+    }
   }
 
   private shouldRetry(response: Response): boolean {

src/core/streaming.ts

@@ -4,6 +4,7 @@ import { makeReadableStream } from '../internal/shims';
 import { findDoubleNewlineIndex, LineDecoder } from '../internal/decoders/line';
 import { ReadableStreamToAsyncIterable } from '../internal/shims';
 import { isAbortError } from '../internal/errors';
+import { encodeUTF8 } from '../internal/utils/bytes';
 
 import { APIError } from './error';
 
@@ -176,9 +177,6 @@ export class Stream<Item> implements AsyncIterable<Item> {
   toReadableStream(): ReadableStream {
     const self = this;
     let iter: AsyncIterator<Item>;
-    const encoder: {
-      encode(str: string): Uint8Array;
-    } = new (globalThis as any).TextEncoder();
 
     return makeReadableStream({
       async start() {
@@ -189,7 +187,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
           const { value, done } = await iter.next();
           if (done) return ctrl.close();
 
-          const bytes = encoder.encode(JSON.stringify(value) + '\n');
+          const bytes = encodeUTF8(JSON.stringify(value) + '\n');
 
           ctrl.enqueue(bytes);
         } catch (err) {
@@ -251,7 +249,7 @@ async function* iterSSEChunks(iterator: AsyncIterableIterator<Bytes>): AsyncGene
 
     const binaryChunk =
       chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
-      : typeof chunk === 'string' ? new (globalThis as any).TextEncoder().encode(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
       : chunk;
 
     let newData = new Uint8Array(data.length + binaryChunk.length);

src/internal/decoders/line.ts

@@ -1,4 +1,4 @@
-import { OpenAIError } from '../../core/error';
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
 
 export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
 
@@ -13,16 +13,11 @@ export class LineDecoder {
   static NEWLINE_CHARS = new Set(['\n', '\r']);
   static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
 
-  buffer: Uint8Array;
+  #buffer: Uint8Array;
   #carriageReturnIndex: number | null;
-  textDecoder:
-    | undefined
-    | {
-        decode(buffer: Uint8Array | ArrayBuffer): string;
-      };
 
   constructor() {
-    this.buffer = new Uint8Array();
+    this.#buffer = new Uint8Array();
     this.#carriageReturnIndex = null;
   }
 
@@ -33,17 +28,14 @@ export class LineDecoder {
 
     const binaryChunk =
       chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
-      : typeof chunk === 'string' ? new TextEncoder().encode(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
       : chunk;
 
-    let newData = new Uint8Array(this.buffer.length + binaryChunk.length);
-    newData.set(this.buffer);
-    newData.set(binaryChunk, this.buffer.length);
-    this.buffer = newData;
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
 
     const lines: string[] = [];
     let patternIndex;
-    while ((patternIndex = findNewlineIndex(this.buffer, this.#carriageReturnIndex)) != null) {
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
       if (patternIndex.carriage && this.#carriageReturnIndex == null) {
         // skip until we either get a corresponding `\n`, a new `\r` or nothing
         this.#carriageReturnIndex = patternIndex.index;
@@ -55,64 +47,27 @@ export class LineDecoder {
         this.#carriageReturnIndex != null &&
         (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
       ) {
-        lines.push(this.decodeText(this.buffer.slice(0, this.#carriageReturnIndex - 1)));
-        this.buffer = this.buffer.slice(this.#carriageReturnIndex);
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
         this.#carriageReturnIndex = null;
         continue;
       }
 
       const endIndex =
         this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
 
-      const line = this.decodeText(this.buffer.slice(0, endIndex));
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
       lines.push(line);
 
-      this.buffer = this.buffer.slice(patternIndex.index);
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
       this.#carriageReturnIndex = null;
     }
 
     return lines;
   }
 
-  decodeText(bytes: Bytes): string {
-    if (bytes == null) return '';
-    if (typeof bytes === 'string') return bytes;
-
-    // Node:
-    if (typeof (globalThis as any).Buffer !== 'undefined') {
-      if (bytes instanceof (globalThis as any).Buffer) {
-        return bytes.toString();
-      }
-      if (bytes instanceof Uint8Array) {
-        return (globalThis as any).Buffer.from(bytes).toString();
-      }
-
-      throw new OpenAIError(
-        `Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`,
-      );
-    }
-
-    // Browser
-    if (typeof (globalThis as any).TextDecoder !== 'undefined') {
-      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
-        this.textDecoder ??= new (globalThis as any).TextDecoder('utf8');
-        return this.textDecoder!.decode(bytes);
-      }
-
-      throw new OpenAIError(
-        `Unexpected: received non-Uint8Array/ArrayBuffer (${
-          (bytes as any).constructor.name
-        }) in a web platform. Please report this error.`,
-      );
-    }
-
-    throw new OpenAIError(
-      `Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.`,
-    );
-  }
-
   flush(): string[] {
-    if (!this.buffer.length) {
+    if (!this.#buffer.length) {
       return [];
     }
     return this.decode('\n');

src/internal/headers.ts

@@ -3,7 +3,7 @@
 type HeaderValue = string | undefined | null;
 export type HeadersLike =
   | Headers
-  | readonly [string, HeaderValue][]
+  | readonly HeaderValue[][]
   | Record<string, HeaderValue | readonly HeaderValue[]>
   | undefined
   | null
@@ -40,7 +40,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
 
   let shouldClear = false;
-  let iter: Iterable<readonly [string, HeaderValue | readonly HeaderValue[]]>;
+  let iter: Iterable<readonly (HeaderValue | readonly HeaderValue[])[]>;
   if (headers instanceof Headers) {
     iter = headers.entries();
   } else if (isArray(headers)) {
@@ -51,6 +51,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
   for (let row of iter) {
     const name = row[0];
+    if (typeof name !== 'string') throw new TypeError('expected header name to be a string');
     const values = isArray(row[1]) ? row[1] : [row[1]];
     let didClear = false;
     for (const value of values) {

src/internal/utils/base64.ts

@@ -1,18 +1,19 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { OpenAIError } from '../../core/error';
+import { encodeUTF8 } from './bytes';
 
 export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
   if (!data) return '';
 
-  if (typeof data === 'string') {
-    data = new (globalThis as any).TextEncoder().encode(data);
-  }
-
   if (typeof (globalThis as any).Buffer !== 'undefined') {
     return (globalThis as any).Buffer.from(data).toString('base64');
   }
 
+  if (typeof data === 'string') {
+    data = encodeUTF8(data);
+  }
+
   if (typeof btoa !== 'undefined') {
     return btoa(String.fromCharCode.apply(null, data as any));
   }

src/internal/utils/bytes.ts

@@ -0,0 +1,32 @@
+export function concatBytes(buffers: Uint8Array[]): Uint8Array {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+
+  return output;
+}
+
+let encodeUTF8_: (str: string) => Uint8Array;
+export function encodeUTF8(str: string) {
+  let encoder;
+  return (
+    encodeUTF8_ ??
+    ((encoder = new (globalThis as any).TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder)))
+  )(str);
+}
+
+let decodeUTF8_: (bytes: Uint8Array) => string;
+export function decodeUTF8(bytes: Uint8Array) {
+  let decoder;
+  return (
+    decodeUTF8_ ??
+    ((decoder = new (globalThis as any).TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder)))
+  )(bytes);
+}