@zimic/http/dist/index.js

Next-gen TypeScript-first HTTP utilities

'use strict';

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// ../zimic-utils/dist/chunk-2D3UJWOA.mjs
var __defProp2 = Object.defineProperty;
var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");

// ../zimic-utils/dist/chunk-GUOR4PHC.mjs
async function blobEquals(blob, otherBlob) {
  if (blob.type !== otherBlob.type || blob.size !== otherBlob.size) {
    return false;
  }
  const reader = blob.stream().getReader();
  const otherReader = otherBlob.stream().getReader();
  let buffer = new Uint8Array(0);
  let otherBuffer = new Uint8Array(0);
  try {
    while (true) {
      await Promise.all([
        buffer.length === 0 && reader.read().then((result) => {
          if (!result.done) {
            buffer = result.value;
          }
        }),
        otherBuffer.length === 0 && otherReader.read().then((result) => {
          if (!result.done) {
            otherBuffer = result.value;
          }
        })
      ]);
      const streamsEndedTogether = buffer.length === 0 && otherBuffer.length === 0;
      if (streamsEndedTogether) {
        return true;
      }
      const oneStreamEndedBeforeTheOther = buffer.length === 0 && otherBuffer.length > 0 || buffer.length > 0 && otherBuffer.length === 0;
      if (oneStreamEndedBeforeTheOther) {
        return false;
      }
      const minimumByteLength = Math.min(buffer.length, otherBuffer.length);
      for (let byteIndex = 0; byteIndex < minimumByteLength; byteIndex++) {
        if (buffer[byteIndex] !== otherBuffer[byteIndex]) {
          return false;
        }
      }
      buffer = buffer.slice(minimumByteLength);
      otherBuffer = otherBuffer.slice(minimumByteLength);
    }
  } finally {
    reader.releaseLock();
    otherReader.releaseLock();
  }
}
__name(blobEquals, "blobEquals");
__name2(blobEquals, "blobEquals");
var blobEquals_default = blobEquals;

// ../zimic-utils/dist/data/fileEquals.mjs
async function fileEquals(file, otherFile) {
  return file.name === otherFile.name && await blobEquals_default(file, otherFile);
}
__name(fileEquals, "fileEquals");
__name2(fileEquals, "fileEquals");
var fileEquals_default = fileEquals;

// src/formData/HttpFormData.ts
var HttpFormData = class extends FormData {
  static {
    __name(this, "HttpFormData");
  }
  _schema;
  set(name, blobOrValue, fileName) {
    if (fileName === void 0) {
      super.set(name, blobOrValue);
    } else {
      super.set(name, blobOrValue, fileName);
    }
  }
  append(name, blobOrValue, fileName) {
    if (fileName === void 0) {
      super.append(name, blobOrValue);
    } else {
      super.append(name, blobOrValue, fileName);
    }
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdataget `formData.get()` API reference} */
  get(name) {
    return super.get(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatagetall `formData.getAll()` API reference} */
  getAll(name) {
    return super.getAll(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatahas `formData.has()` API reference} */
  has(name) {
    return super.has(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatadelete `formData.delete()` API reference} */
  delete(name) {
    super.delete(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdataforEach `formData.forEach()` API reference} */
  forEach(callback, thisArg) {
    super.forEach(callback, thisArg);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatakeys `formData.keys()` API reference} */
  keys() {
    return super.keys();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatavalues `formData.values()` API reference} */
  values() {
    return super.values();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdataentries `formData.entries()` API reference} */
  entries() {
    return super.entries();
  }
  [Symbol.iterator]() {
    return super[Symbol.iterator]();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdataequals `formData.equals()` API reference} */
  async equals(otherData) {
    if (!await this.contains(otherData)) {
      return false;
    }
    for (const key of this.keys()) {
      const otherHasKey = super.has.call(otherData, key);
      if (!otherHasKey) {
        return false;
      }
    }
    return true;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatacontains `formData.contains()` API reference} */
  async contains(otherData) {
    for (const [otherKey, otherValue] of otherData.entries()) {
      const values = super.getAll.call(this, otherKey);
      const haveSameNumberOfValues = values.length === super.getAll.call(otherData, otherKey).length;
      if (!haveSameNumberOfValues) {
        return false;
      }
      let valueExists = false;
      for (const value of values) {
        if (value === otherValue || value instanceof Blob && otherValue instanceof Blob && await fileEquals_default(value, otherValue)) {
          valueExists = true;
          break;
        }
      }
      if (!valueExists) {
        return false;
      }
    }
    return true;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-form-data#formdatatoobject `formData.toObject()` API reference} */
  toObject() {
    const object = {};
    for (const [key, value] of this.entries()) {
      if (key in object) {
        const existingValue = object[key];
        if (Array.isArray(existingValue)) {
          existingValue.push(value);
        } else {
          object[key] = [existingValue, value];
        }
      } else {
        object[key] = value;
      }
    }
    return object;
  }
};
var HttpFormData_default = HttpFormData;

// src/headers/HttpHeaders.ts
function pickPrimitiveProperties(schema) {
  return Object.entries(schema).reduce((accumulated, [key, value]) => {
    if (value !== void 0) {
      accumulated[key] = String(value);
    }
    return accumulated;
  }, {});
}
__name(pickPrimitiveProperties, "pickPrimitiveProperties");
var HttpHeaders = class extends Headers {
  static {
    __name(this, "HttpHeaders");
  }
  _schema;
  constructor(init) {
    if (init instanceof Headers || Array.isArray(init) || !init) {
      super(init);
    } else {
      super(pickPrimitiveProperties(init));
    }
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersset `headers.set()` API reference} */
  set(name, value) {
    super.set(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersappend `headers.append()` API reference} */
  append(name, value) {
    super.append(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersget `headers.get()` API reference} */
  get(name) {
    return super.get(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersgetSetCookie `headers.getSetCookie()` API reference} */
  getSetCookie() {
    return super.getSetCookie();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headershas `headers.has()` API reference} */
  has(name) {
    return super.has(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersdelete `headers.delete()` API reference} */
  delete(name) {
    super.delete(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersforEach `headers.forEach()` API reference} */
  forEach(callback, thisArg) {
    super.forEach(callback, thisArg);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headerskeys `headers.keys()` API reference} */
  keys() {
    return super.keys();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersvalues `headers.values()` API reference} */
  values() {
    return super.values();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersentries `headers.entries()` API reference} */
  entries() {
    return super.entries();
  }
  [Symbol.iterator]() {
    return super[Symbol.iterator]();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headersequals `headers.equals()` API reference} */
  equals(otherHeaders) {
    if (!this.contains(otherHeaders)) {
      return false;
    }
    for (const key of this.keys()) {
      const otherHasKey = super.has.call(otherHeaders, key);
      if (!otherHasKey) {
        return false;
      }
    }
    return true;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headerscontains `headers.contains()` API reference} */
  contains(otherHeaders) {
    for (const [key, otherValue] of otherHeaders.entries()) {
      const value = super.get.call(this, key);
      if (value === null) {
        return false;
      }
      const valueItems = this.splitHeaderValues(value);
      const otherValueItems = this.splitHeaderValues(otherValue);
      const haveSameNumberOfValues = valueItems.length === otherValueItems.length;
      if (!haveSameNumberOfValues) {
        return false;
      }
      for (const otherValueItem of otherValueItems) {
        if (!valueItems.includes(otherValueItem)) {
          return false;
        }
      }
    }
    return true;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-headers#headerstoobject `headers.toObject()` API reference} */
  toObject() {
    const object = {};
    for (const [key, value] of this.entries()) {
      object[key] = value;
    }
    return object;
  }
  splitHeaderValues(value) {
    return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
  }
};
var HttpHeaders_default = HttpHeaders;

// src/searchParams/HttpSearchParams.ts
function pickPrimitiveProperties2(schema) {
  const schemaWithPrimitiveProperties = Object.entries(schema).reduce(
    (accumulated, [key, value]) => {
      if (value !== void 0 && !Array.isArray(value)) {
        accumulated[key] = String(value);
      }
      return accumulated;
    },
    {}
  );
  return schemaWithPrimitiveProperties;
}
__name(pickPrimitiveProperties2, "pickPrimitiveProperties");
var HttpSearchParams = class extends URLSearchParams {
  static {
    __name(this, "HttpSearchParams");
  }
  _schema;
  constructor(init) {
    if (init instanceof URLSearchParams || Array.isArray(init) || typeof init === "string" || !init) {
      super(init);
    } else {
      super(pickPrimitiveProperties2(init));
      this.populateInitArrayProperties(init);
    }
  }
  populateInitArrayProperties(init) {
    for (const [key, value] of Object.entries(init)) {
      if (Array.isArray(value)) {
        for (const item of value) {
          super.append(key, String(item));
        }
      }
    }
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsset `searchParams.set()` API reference} */
  set(name, value) {
    super.set(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsappend `searchParams.append()` API reference} */
  append(name, value) {
    super.append(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsget `searchParams.get()` API reference} */
  get(name) {
    return super.get(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsgetall `searchParams.getAll()` API reference} */
  getAll(name) {
    return super.getAll(name);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamshas `searchParams.has()` API reference} */
  has(name, value) {
    return super.has(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsdelete `searchParams.delete()` API reference} */
  delete(name, value) {
    super.delete(name, value);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsforEach `searchParams.forEach()` API reference} */
  forEach(callback, thisArg) {
    super.forEach(callback, thisArg);
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamskeys `searchParams.keys()` API reference} */
  keys() {
    return super.keys();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsvalues `searchParams.values()` API reference} */
  values() {
    return super.values();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsentries `searchParams.entries()` API reference} */
  entries() {
    return super.entries();
  }
  [Symbol.iterator]() {
    return super[Symbol.iterator]();
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamsequals `searchParams.equals()` API reference} */
  equals(otherParams) {
    return this.contains(otherParams) && this.size === otherParams.size;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamscontains `searchParams.contains()` API reference} */
  contains(otherParams) {
    for (const [key, otherValue] of otherParams.entries()) {
      const values = super.getAll.call(this, key);
      const haveSameNumberOfValues = values.length === super.getAll.call(otherParams, key).length;
      if (!haveSameNumberOfValues) {
        return false;
      }
      const valueExists = values.includes(otherValue);
      if (!valueExists) {
        return false;
      }
    }
    return true;
  }
  /** @see {@link https://zimic.dev/docs/http/api/http-search-params#searchparamstoobject `searchParams.toObject()` API reference} */
  toObject() {
    const object = {};
    for (const [key, value] of this.entries()) {
      if (key in object) {
        const existingValue = object[key];
        if (Array.isArray(existingValue)) {
          existingValue.push(value);
        } else {
          object[key] = [existingValue, value];
        }
      } else {
        object[key] = value;
      }
    }
    return object;
  }
};
var HttpSearchParams_default = HttpSearchParams;

// src/types/schema.ts
var HTTP_METHODS = Object.freeze(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);

exports.HTTP_METHODS = HTTP_METHODS;
exports.HttpFormData = HttpFormData_default;
exports.HttpHeaders = HttpHeaders_default;
exports.HttpSearchParams = HttpSearchParams_default;
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map