react-native-nitro-fetch 1.3.0 → 1.3.2

package/src/Response.js

@@ -0,0 +1,260 @@
+import { NitroHeaders } from './Headers';
+import { stringToUTF8, utf8ToString } from './utf8';
+function isNitroResponseInit(arg) {
+  return (
+    arg != null &&
+    typeof arg === 'object' &&
+    'url' in arg &&
+    'status' in arg &&
+    'ok' in arg
+  );
+}
+export class NitroResponse {
+  url;
+  ok;
+  status;
+  statusText;
+  redirected;
+  headers;
+  type;
+  _bodyBytes;
+  _bodyString;
+  _bodyStream;
+  _bodyUsed = false;
+  constructor(bodyOrInit, init) {
+    if (isNitroResponseInit(bodyOrInit)) {
+      // Internal constructor path
+      const nitroInit = bodyOrInit;
+      this.url = nitroInit.url;
+      this.ok = nitroInit.ok;
+      this.status = nitroInit.status;
+      this.statusText = nitroInit.statusText;
+      this.redirected = nitroInit.redirected;
+      this.type = nitroInit.type ?? 'basic';
+      if (nitroInit.headers instanceof NitroHeaders) {
+        this.headers = nitroInit.headers;
+      } else {
+        this.headers = new NitroHeaders(nitroInit.headers);
+      }
+      this._bodyBytes = nitroInit.bodyBytes;
+      this._bodyString = nitroInit.bodyString;
+      this._bodyStream = nitroInit.body;
+    } else {
+      // Public constructor: new Response(body?, init?)
+      const body = bodyOrInit;
+      this.status = init?.status ?? 200;
+      this.statusText = init?.statusText ?? '';
+      this.ok = this.status >= 200 && this.status < 300;
+      this.url = '';
+      this.redirected = false;
+      this.type = 'default';
+      this.headers = new NitroHeaders(init?.headers);
+      if (body == null) {
+        // no body
+      } else if (typeof body === 'string') {
+        this._bodyString = body;
+      } else if (body instanceof ArrayBuffer) {
+        this._bodyBytes = body;
+      } else if (ArrayBuffer.isView(body)) {
+        const view = body;
+        this._bodyBytes = view.buffer.slice(
+          view.byteOffset,
+          view.byteOffset + view.byteLength
+        );
+      } else if (
+        typeof ReadableStream !== 'undefined' &&
+        body instanceof ReadableStream
+      ) {
+        this._bodyStream = body;
+      } else if (
+        typeof URLSearchParams !== 'undefined' &&
+        body instanceof URLSearchParams
+      ) {
+        this._bodyString = body.toString();
+        if (!this.headers.has('content-type')) {
+          this.headers.set(
+            'content-type',
+            'application/x-www-form-urlencoded;charset=UTF-8'
+          );
+        }
+      } else if (typeof Blob !== 'undefined' && body instanceof Blob) {
+        // Store as string — RN Blobs are string-backed
+        this._bodyString = '';
+        this._bodyStream = body.stream?.();
+      }
+    }
+  }
+  get bodyUsed() {
+    return this._bodyUsed;
+  }
+  get body() {
+    if (this._bodyStream) return this._bodyStream;
+    const bytes = this._getBodyBytes();
+    if (!bytes) return null;
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(new Uint8Array(bytes));
+        controller.close();
+      },
+    });
+  }
+  _throwIfBodyUsed() {
+    if (this._bodyUsed) {
+      throw new TypeError('Body has already been consumed.');
+    }
+  }
+  _getBodyBytes() {
+    // TODO: copy buffer to avoid clone being modifying res
+    if (this._bodyBytes != null) return this._bodyBytes;
+    if (this._bodyString != null) {
+      const encoded = stringToUTF8(this._bodyString);
+      return encoded.buffer.slice(
+        encoded.byteOffset,
+        encoded.byteOffset + encoded.byteLength
+      );
+    }
+    return undefined;
+  }
+  _getBodyString() {
+    if (this._bodyString != null) return this._bodyString;
+    if (this._bodyBytes) {
+      return utf8ToString(new Uint8Array(this._bodyBytes));
+    }
+    return '';
+  }
+  async text() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    if (this._bodyStream && !this._bodyBytes && this._bodyString == null) {
+      const reader = this._bodyStream.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+      // Concatenate chunks
+      let totalLen = 0;
+      for (const c of chunks) totalLen += c.byteLength;
+      const merged = new Uint8Array(totalLen);
+      let offset = 0;
+      for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.byteLength;
+      }
+      return utf8ToString(merged);
+    }
+    return this._getBodyString();
+  }
+  async json() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const t = this._getBodyString();
+    return JSON.parse(t || '{}');
+  }
+  async arrayBuffer() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    if (this._bodyStream && !this._bodyBytes && this._bodyString == null) {
+      const reader = this._bodyStream.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) chunks.push(value);
+      }
+      let totalLen = 0;
+      for (const c of chunks) totalLen += c.byteLength;
+      const merged = new Uint8Array(totalLen);
+      let offset = 0;
+      for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.byteLength;
+      }
+      return merged.buffer.slice(
+        merged.byteOffset,
+        merged.byteOffset + merged.byteLength
+      );
+    }
+    return this._getBodyBytes() ?? new ArrayBuffer(0);
+  }
+  async blob() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    // RN's Blob doesn't support ArrayBuffer/ArrayBufferView — use string body
+    const bodyStr = this._getBodyString();
+    const contentType = this.headers.get('content-type') ?? '';
+    return new Blob([bodyStr], { type: contentType });
+  }
+  async bytes() {
+    this._throwIfBodyUsed();
+    this._bodyUsed = true;
+    const buffer = this._getBodyBytes() ?? new ArrayBuffer(0);
+    return new Uint8Array(buffer);
+  }
+  clone() {
+    if (this._bodyUsed) {
+      throw new TypeError('Cannot clone a Response whose body has been used.');
+    }
+    return new NitroResponse({
+      url: this.url,
+      status: this.status,
+      statusText: this.statusText,
+      ok: this.ok,
+      redirected: this.redirected,
+      headers: this.headers,
+      bodyBytes: this._bodyBytes,
+      bodyString: this._bodyString,
+      type: this.type,
+    });
+  }
+  async formData() {
+    throw new TypeError('formData() is not supported in NitroResponse');
+  }
+  // --- Static methods ---
+  static error() {
+    return new NitroResponse({
+      url: '',
+      status: 0,
+      statusText: '',
+      ok: false,
+      redirected: false,
+      headers: [],
+      type: 'error',
+    });
+  }
+  static json(data, init) {
+    const body = JSON.stringify(data);
+    const headers = new NitroHeaders(init?.headers);
+    if (!headers.has('content-type')) {
+      headers.set('content-type', 'application/json');
+    }
+    return new NitroResponse({
+      url: '',
+      status: init?.status ?? 200,
+      statusText: init?.statusText ?? '',
+      ok: (init?.status ?? 200) >= 200 && (init?.status ?? 200) < 300,
+      redirected: false,
+      headers,
+      bodyString: body,
+    });
+  }
+  static redirect(url, status = 302) {
+    const validStatuses = [301, 302, 303, 307, 308];
+    if (!validStatuses.includes(status)) {
+      throw new RangeError(
+        `Invalid redirect status: ${status}. Must be one of ${validStatuses.join(', ')}`
+      );
+    }
+    const headers = new NitroHeaders();
+    headers.set('location', url);
+    return new NitroResponse({
+      url: '',
+      status,
+      statusText: '',
+      ok: false,
+      redirected: false,
+      headers,
+    });
+  }
+}