rezo 1.0.30 → 1.0.32

package/dist/responses/universal/stream.js

@@ -0,0 +1,31 @@
+import { UniversalEventEmitter } from './event-emitter.js';
+
+export class UniversalStreamResponse extends UniversalEventEmitter {
+  _finished = false;
+  _encoding;
+  constructor() {
+    super();
+  }
+  setEncoding(encoding) {
+    this._encoding = encoding;
+    return this;
+  }
+  getEncoding() {
+    return this._encoding;
+  }
+  isFinished() {
+    return this._finished;
+  }
+  _markFinished() {
+    this._finished = true;
+  }
+  write(chunk) {
+    this.emit("data", chunk);
+  }
+  end() {
+    this._finished = true;
+    this.emit("close");
+  }
+}
+
+export { UniversalStreamResponse as StreamResponse };

package/dist/responses/universal/upload.cjs

@@ -0,0 +1,23 @@
+const { UniversalEventEmitter } = require('./event-emitter.cjs');
+
+class UniversalUploadResponse extends UniversalEventEmitter {
+  url;
+  fileName;
+  status;
+  statusText;
+  _finished = false;
+  constructor(url, fileName) {
+    super();
+    this.url = url;
+    this.fileName = fileName;
+  }
+  isFinished() {
+    return this._finished;
+  }
+  _markFinished() {
+    this._finished = true;
+  }
+}
+
+exports.UploadResponse = UniversalUploadResponse;
+exports.UniversalUploadResponse = UniversalUploadResponse;

package/dist/responses/universal/upload.js

@@ -0,0 +1,22 @@
+import { UniversalEventEmitter } from './event-emitter.js';
+
+export class UniversalUploadResponse extends UniversalEventEmitter {
+  url;
+  fileName;
+  status;
+  statusText;
+  _finished = false;
+  constructor(url, fileName) {
+    super();
+    this.url = url;
+    this.fileName = fileName;
+  }
+  isFinished() {
+    return this._finished;
+  }
+  _markFinished() {
+    this._finished = true;
+  }
+}
+
+export { UniversalUploadResponse as UploadResponse };

package/dist/utils/cookies.browser.cjs

@@ -0,0 +1,63 @@
+class Cookie {
+  key;
+  value;
+  domain = null;
+  path = "/";
+  expires = null;
+  httpOnly = false;
+  secure = false;
+  sameSite;
+  maxAge = null;
+  constructor(options) {
+    this.key = options.key;
+    this.value = options.value;
+  }
+  toString() {
+    return `${this.key}=${this.value}`;
+  }
+  toJSON() {
+    return { key: this.key, value: this.value };
+  }
+  static parse(_str) {
+    return null;
+  }
+}
+const EMPTY_COOKIES = { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+
+class RezoCookieJar {
+  constructor(_cookies, _url) {}
+  setCookie(_c, _u) {}
+  setCookiesSync(_c, _u) {}
+  getCookiesSync(_u) {
+    return [];
+  }
+  getCookieStringSync(_u) {
+    return "";
+  }
+  removeAllCookiesSync() {}
+  cookies() {
+    return EMPTY_COOKIES;
+  }
+  toJSON() {
+    return [];
+  }
+  static fromJSON(_d) {
+    return new RezoCookieJar;
+  }
+  generateCookies(_u, _s) {
+    return [];
+  }
+  parseResponseCookies(_s, _u) {
+    return [];
+  }
+  toCookieString(_u) {
+    return "";
+  }
+  toNetscapeCookie() {
+    return "";
+  }
+}
+
+exports.default = Cookie;
+exports.Cookie = Cookie;
+exports.RezoCookieJar = RezoCookieJar;

package/dist/utils/cookies.browser.js

@@ -0,0 +1,61 @@
+export class Cookie {
+  key;
+  value;
+  domain = null;
+  path = "/";
+  expires = null;
+  httpOnly = false;
+  secure = false;
+  sameSite;
+  maxAge = null;
+  constructor(options) {
+    this.key = options.key;
+    this.value = options.value;
+  }
+  toString() {
+    return `${this.key}=${this.value}`;
+  }
+  toJSON() {
+    return { key: this.key, value: this.value };
+  }
+  static parse(_str) {
+    return null;
+  }
+}
+const EMPTY_COOKIES = { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+
+export class RezoCookieJar {
+  constructor(_cookies, _url) {}
+  setCookie(_c, _u) {}
+  setCookiesSync(_c, _u) {}
+  getCookiesSync(_u) {
+    return [];
+  }
+  getCookieStringSync(_u) {
+    return "";
+  }
+  removeAllCookiesSync() {}
+  cookies() {
+    return EMPTY_COOKIES;
+  }
+  toJSON() {
+    return [];
+  }
+  static fromJSON(_d) {
+    return new RezoCookieJar;
+  }
+  generateCookies(_u, _s) {
+    return [];
+  }
+  parseResponseCookies(_s, _u) {
+    return [];
+  }
+  toCookieString(_u) {
+    return "";
+  }
+  toNetscapeCookie() {
+    return "";
+  }
+}
+
+export { Cookie as default };

package/dist/utils/form-data.cjs

@@ -1,218 +1,241 @@
-const NodeFormData = require("form-data");
-function isReadableStream(value) {
-  return value !== null && typeof value === "object" && typeof value.pipe === "function" && typeof value.read === "function" && typeof value.on === "function";
+const hasBuffer = typeof Buffer !== "undefined";
+function isBuffer(value) {
+  return hasBuffer && Buffer.isBuffer(value);
+}
+function toBlob(value, contentType) {
+  const options = contentType ? { type: contentType } : undefined;
+  const copy = new ArrayBuffer(value.byteLength);
+  new Uint8Array(copy).set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return new Blob([copy], options);
 }
 
-class RezoFormData extends NodeFormData {
-  constructor(options) {
-    super(options);
-  }
-  async getFieldEntries() {
-    return new Promise((resolve, reject) => {
-      const entries = [];
-      const fields = this._fields || [];
-      for (const field of fields) {
-        if (field && field.name && field.value !== undefined) {
-          entries.push([field.name, field.value]);
-        }
-      }
-      resolve(entries);
-    });
+class RezoFormData {
+  _fd;
+  _cachedContentType = null;
+  _cachedBuffer = null;
+  constructor() {
+    this._fd = new FormData;
   }
-  async toNativeFormData() {
-    if (typeof globalThis !== "undefined" && typeof globalThis.FormData !== "undefined" || typeof global !== "undefined" && typeof global.FormData !== "undefined" || typeof window !== "undefined" && typeof window.FormData !== "undefined") {
-      const formData = new FormData;
-      const entries = await this.getFieldEntries();
-      for (const [key, value] of entries) {
-        if (isReadableStream(value)) {
-          const chunks = [];
-          for await (const chunk of value) {
-            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-          }
-          const buffer = Buffer.concat(chunks);
-          const blob = new Blob([buffer]);
-          formData.append(key, blob);
-        } else {
-          formData.append(key, value);
-        }
+  append(name, value, filename) {
+    this._invalidateCache();
+    if (isBuffer(value)) {
+      const blob = toBlob(value);
+      if (filename) {
+        this._fd.append(name, blob, filename);
+      } else {
+        this._fd.append(name, blob);
       }
-      return formData;
+    } else if (filename && value instanceof Blob) {
+      this._fd.append(name, value, filename);
+    } else {
+      this._fd.append(name, value);
     }
-    return null;
-  }
-  static async fromNativeFormData(formData, options) {
-    const rezoFormData = new RezoFormData(options);
-    for (const [key, value] of Array.from(formData.entries())) {
-      if (typeof File !== "undefined" && value instanceof File) {
-        const file = value;
-        const arrayBuffer = await file.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        rezoFormData.append(key, buffer, {
-          filename: file.name,
-          contentType: file.type || "application/octet-stream"
-        });
-      } else if (typeof Blob !== "undefined" && value instanceof Blob) {
-        const blob = value;
-        const arrayBuffer = await blob.arrayBuffer();
-        const buffer = Buffer.from(arrayBuffer);
-        rezoFormData.append(key, buffer, {
-          contentType: blob.type || "application/octet-stream"
-        });
+  }
+  set(name, value, filename) {
+    this._invalidateCache();
+    if (isBuffer(value)) {
+      const blob = toBlob(value);
+      if (filename) {
+        this._fd.set(name, blob, filename);
       } else {
-        rezoFormData.append(key, value);
+        this._fd.set(name, blob);
       }
+    } else if (filename && value instanceof Blob) {
+      this._fd.set(name, value, filename);
+    } else {
+      this._fd.set(name, value);
     }
-    return rezoFormData;
   }
-  getContentType() {
-    return `multipart/form-data; boundary=${this.getBoundary()}`;
+  get(name) {
+    return this._fd.get(name);
   }
-  toBuffer() {
-    return Buffer.from(this.toString());
+  getAll(name) {
+    return this._fd.getAll(name);
   }
-  static fromObject(obj, options) {
-    const formData = new RezoFormData(options);
-    for (const [key, value] of Object.entries(obj)) {
-      RezoFormData.appendValue(formData, key, value);
-    }
-    return formData;
+  has(name) {
+    return this._fd.has(name);
   }
-  static appendValue(formData, key, value) {
-    if (value === null || value === undefined) {
-      return;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      formData.append(key, String(value));
-      return;
-    }
-    if (Buffer.isBuffer(value)) {
-      formData.append(key, value, {
-        contentType: "application/octet-stream"
-      });
-      return;
-    }
-    if (value instanceof Uint8Array) {
-      formData.append(key, Buffer.from(value), {
-        contentType: "application/octet-stream"
-      });
-      return;
-    }
-    if (isReadableStream(value)) {
-      formData.append(key, value);
-      return;
-    }
-    if (typeof File !== "undefined" && value instanceof File) {
-      formData.append(key, value, {
-        filename: value.name,
-        contentType: value.type || "application/octet-stream"
-      });
-      return;
-    }
-    if (typeof Blob !== "undefined" && value instanceof Blob) {
-      formData.append(key, value, {
-        contentType: value.type || "application/octet-stream"
-      });
-      return;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        RezoFormData.appendValue(formData, key, item);
-      }
-      return;
+  delete(name) {
+    this._invalidateCache();
+    this._fd.delete(name);
+  }
+  entries() {
+    return this._fd.entries();
+  }
+  keys() {
+    return this._fd.keys();
+  }
+  values() {
+    return this._fd.values();
+  }
+  forEach(callback) {
+    this._fd.forEach(callback);
+  }
+  [Symbol.iterator]() {
+    return this._fd.entries();
+  }
+  toNativeFormData() {
+    return this._fd;
+  }
+  _invalidateCache() {
+    this._cachedContentType = null;
+    this._cachedBuffer = null;
+  }
+  async _buildResponse() {
+    if (this._cachedBuffer === null || this._cachedContentType === null) {
+      const response = new Response(this._fd);
+      this._cachedContentType = response.headers.get("content-type") || "multipart/form-data";
+      this._cachedBuffer = await response.arrayBuffer();
+    }
+    return new Response(this._cachedBuffer, {
+      headers: { "content-type": this._cachedContentType }
+    });
+  }
+  getBoundary() {
+    if (!this._cachedContentType) {
+      return "";
     }
-    if (typeof value === "object" && value !== null && "value" in value && (value.filename || value.contentType)) {
-      const opts = {};
-      if (value.filename)
-        opts.filename = value.filename;
-      if (value.contentType)
-        opts.contentType = value.contentType;
-      formData.append(key, value.value, opts);
-      return;
+    const match = this._cachedContentType.match(/boundary=([^;]+)/);
+    return match ? match[1] : "";
+  }
+  getContentType() {
+    return this._cachedContentType || undefined;
+  }
+  async getContentTypeAsync() {
+    await this._buildResponse();
+    return this._cachedContentType;
+  }
+  getHeaders() {
+    if (this._cachedContentType) {
+      return { "content-type": this._cachedContentType };
     }
-    if (typeof value === "object" && value !== null) {
-      const jsonString = JSON.stringify(value);
-      const jsonBuffer = Buffer.from(jsonString, "utf8");
-      formData.append(key, jsonBuffer, {
-        filename: `${key}.json`,
-        contentType: "application/json"
-      });
-      return;
+    return {};
+  }
+  async getHeadersAsync() {
+    const contentType = await this.getContentTypeAsync();
+    const length = await this.getLength();
+    return {
+      "content-type": contentType,
+      "content-length": String(length)
+    };
+  }
+  getLengthSync() {
+    return this._cachedBuffer?.byteLength;
+  }
+  async getLength() {
+    await this._buildResponse();
+    return this._cachedBuffer.byteLength;
+  }
+  getBuffer() {
+    if (!hasBuffer || !this._cachedBuffer) {
+      return null;
     }
-    formData.append(key, String(value));
+    return Buffer.from(this._cachedBuffer);
   }
-  async toUrlQueryString(convertBinaryToBase64 = false) {
-    const params = new URLSearchParams;
-    let hasOmittedData = false;
-    try {
-      const entries = await this.getFieldEntries();
-      for (const [name, value] of entries) {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-          params.append(name, String(value));
-        } else if (value instanceof Buffer) {
-          if (convertBinaryToBase64) {
-            params.append(name, value.toString("base64"));
-          } else {
-            hasOmittedData = true;
-          }
-        } else if (isReadableStream(value) || typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob) {
-          if (convertBinaryToBase64 && value instanceof File) {
-            hasOmittedData = true;
-          } else {
-            hasOmittedData = true;
-          }
-        } else if (typeof value === "object" && value && "value" in value) {
-          if (typeof value.value === "string" || typeof value.value === "number" || typeof value.value === "boolean") {
-            params.append(name, String(value.value));
+  async toBuffer() {
+    await this._buildResponse();
+    return Buffer.from(this._cachedBuffer);
+  }
+  async toArrayBuffer() {
+    await this._buildResponse();
+    return this._cachedBuffer;
+  }
+  async toUint8Array() {
+    await this._buildResponse();
+    return new Uint8Array(this._cachedBuffer);
+  }
+  static fromObject(obj) {
+    const fd = new RezoFormData;
+    const appendValue = (key, value) => {
+      if (value === null || value === undefined) {
+        return;
+      }
+      if (typeof value === "string") {
+        fd.append(key, value);
+        return;
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        fd.append(key, String(value));
+        return;
+      }
+      if (value instanceof Blob) {
+        const filename = value instanceof File ? value.name : undefined;
+        fd.append(key, value, filename);
+        return;
+      }
+      if (isBuffer(value)) {
+        fd.append(key, toBlob(value));
+        return;
+      }
+      if (value instanceof Uint8Array) {
+        fd.append(key, toBlob(value));
+        return;
+      }
+      if (value instanceof ArrayBuffer) {
+        fd.append(key, new Blob([value]));
+        return;
+      }
+      if (Array.isArray(value)) {
+        for (let i = 0;i < value.length; i++) {
+          appendValue(`${key}[${i}]`, value[i]);
+        }
+        return;
+      }
+      if (typeof value === "object" && value !== null) {
+        if ("value" in value && (("filename" in value) || ("contentType" in value))) {
+          const v = value;
+          if (v.value instanceof Blob) {
+            fd.append(key, v.value, v.filename);
+          } else if (isBuffer(v.value)) {
+            const blob = toBlob(v.value, v.contentType);
+            fd.append(key, blob, v.filename);
+          } else if (v.value instanceof Uint8Array) {
+            const blob = toBlob(v.value, v.contentType);
+            fd.append(key, blob, v.filename);
           } else {
-            hasOmittedData = true;
+            fd.append(key, String(v.value));
           }
-        } else {
-          hasOmittedData = true;
+          return;
         }
+        for (const [subKey, subValue] of Object.entries(value)) {
+          appendValue(`${key}[${subKey}]`, subValue);
+        }
+        return;
       }
-    } catch (error) {
-      console.warn("RezoFormData.toUrlQueryString(): Error reading form data entries:", error);
+      fd.append(key, String(value));
+    };
+    for (const [key, value] of Object.entries(obj)) {
+      appendValue(key, value);
     }
-    if (hasOmittedData && !convertBinaryToBase64) {
-      console.warn("RezoFormData.toUrlQueryString(): Binary data, files, and blobs have been omitted. Use convertBinaryToBase64=true to include binary data as base64 strings.");
+    return fd;
+  }
+  static fromNativeFormData(formData) {
+    const fd = new RezoFormData;
+    for (const [key, value] of formData.entries()) {
+      if (typeof value === "string") {
+        fd.append(key, value);
+      } else {
+        const filename = value.name || undefined;
+        fd.append(key, value, filename);
+      }
     }
-    return params.toString();
+    return fd;
   }
-  async toURLSearchParams(convertBinaryToBase64 = false) {
+  toUrlQueryString() {
     const params = new URLSearchParams;
-    let hasOmittedData = false;
-    try {
-      const entries = await this.getFieldEntries();
-      for (const [name, value] of entries) {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-          params.append(name, String(value));
-        } else if (value instanceof Buffer) {
-          if (convertBinaryToBase64) {
-            params.append(name, value.toString("base64"));
-          } else {
-            hasOmittedData = true;
-          }
-        } else if (isReadableStream(value) || typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob) {
-          if (convertBinaryToBase64 && value instanceof File) {
-            hasOmittedData = true;
-          } else {
-            hasOmittedData = true;
-          }
-        } else if (typeof value === "object" && value && "value" in value) {
-          if (typeof value.value === "string" || typeof value.value === "number" || typeof value.value === "boolean") {
-            params.append(name, String(value.value));
-          } else {
-            hasOmittedData = true;
-          }
-        } else {
-          hasOmittedData = true;
-        }
+    for (const [key, value] of this._fd.entries()) {
+      if (typeof value === "string") {
+        params.append(key, value);
       }
-    } catch (error) {
-      console.warn("RezoFormData.toURLSearchParams(): Error reading form data entries:", error);
     }
-    if (hasOmittedData && !convertBinaryToBase64) {
-      console.warn("RezoFormData.toURLSearchParams(): Binary data, files, and blobs have been omitted. Use convertBinaryToBase64=true to include binary data as base64 strings.");
+    return params.toString();
+  }
+  toURLSearchParams() {
+    const params = new URLSearchParams;
+    for (const [key, value] of this._fd.entries()) {
+      if (typeof value === "string") {
+        params.append(key, value);
+      }
     }
     return params;
   }