@zimic/http 0.0.1-canary.2

package/dist/index.js

@@ -0,0 +1,544 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/utils/data.ts
+async function blobEquals(blob, otherBlob) {
+  return blob.type === otherBlob.type && blob.size === otherBlob.size && await blob.text() === await otherBlob.text();
+}
+__name(blobEquals, "blobEquals");
+
+// src/utils/imports.ts
+function createCachedDynamicImport(importModuleDynamically) {
+  let cachedImportResult;
+  return /* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
+    if (cachedImportResult === undefined) {
+      cachedImportResult = await importModuleDynamically();
+    }
+    return cachedImportResult;
+  }, "importModuleDynamicallyWithCache");
+}
+__name(createCachedDynamicImport, "createCachedDynamicImport");
+async function fileEquals(file, otherFile) {
+  return file.name === otherFile.name && await blobEquals(file, otherFile);
+}
+__name(fileEquals, "fileEquals");
+
+// src/formData/HttpFormData.ts
+var HttpFormData = class extends FormData {
+  static {
+    __name(this, "HttpFormData");
+  }
+  set(name, blobOrValue, fileName) {
+    if (fileName === undefined) {
+      super.set(name, blobOrValue);
+    } else {
+      super.set(name, blobOrValue, fileName);
+    }
+  }
+  append(name, blobOrValue, fileName) {
+    if (fileName === undefined) {
+      super.append(name, blobOrValue);
+    } else {
+      super.append(name, blobOrValue, fileName);
+    }
+  }
+  /**
+   * Get the value of the entry associated to a key name.
+   *
+   * If the key might have multiple values, use {@link HttpFormData#getAll} instead.
+   *
+   * @param name The name of the key to get the value of.
+   * @returns The value associated with the key name, or `null` if the key does not exist.
+   * @see {@link https://developer.mozilla.org/docs/Web/API/FormData/get MDN Reference}
+   */
+  get(name) {
+    return super.get(name);
+  }
+  /**
+   * Get all the values of the entry associated with a key name.
+   *
+   * If the key has at most a single value, use {@link HttpFormData#get} instead.
+   *
+   * @param name The name of the key to get the values of.
+   * @returns An array of values associated with the key name, or an empty array if the key does not exist.
+   * @see {@link https://developer.mozilla.org/docs/Web/API/FormData/getAll MDN Reference}
+   */
+  getAll(name) {
+    return super.getAll(name);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/has MDN Reference} */
+  has(name) {
+    return super.has(name);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/delete MDN Reference} */
+  delete(name) {
+    super.delete(name);
+  }
+  forEach(callback, thisArg) {
+    super.forEach(callback, thisArg);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/keys MDN Reference} */
+  keys() {
+    return super.keys();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/values MDN Reference} */
+  values() {
+    return super.values();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/FormData/entries MDN Reference} */
+  entries() {
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return super[Symbol.iterator]();
+  }
+  /**
+   * Checks if the data is equal to the other data. Equality is defined as having the same keys and values, regardless
+   * of the order of keys.
+   *
+   * @param otherData The other data to compare.
+   * @returns A promise that resolves with `true` if the data is equal to the other data, or `false` otherwise.
+   *   Important: both form data might be read while comparing.
+   */
+  async equals(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(value, otherValue)) {
+          valueExists = true;
+          break;
+        }
+      }
+      if (!valueExists) {
+        return false;
+      }
+    }
+    for (const key of this.keys()) {
+      const otherHasKey = super.has.call(otherData, key);
+      if (!otherHasKey) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Checks if the data contains the other data. This method is less strict than {@link HttpFormData#equals} and only
+   * requires that all keys and values in the other data are present in this data.
+   *
+   * @param otherData The other data to compare.
+   * @returns A promise that resolves with `true` if this data contains the other data, or `false` otherwise. Important:
+   *   both form data might be read while comparing.
+   */
+  async contains(otherData) {
+    for (const [otherKey, otherValue] of otherData.entries()) {
+      const values = super.getAll.call(this, otherKey);
+      const haveCompatibleNumberOfValues = values.length >= super.getAll.call(otherData, otherKey).length;
+      if (!haveCompatibleNumberOfValues) {
+        return false;
+      }
+      let valueExists = false;
+      for (const value of values) {
+        if (value === otherValue || typeof value === "string" && typeof otherValue === "string" && value === otherValue || value instanceof Blob && otherValue instanceof Blob && await fileEquals(value, otherValue)) {
+          valueExists = true;
+          break;
+        }
+      }
+      if (!valueExists) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Converts this form data into a plain object. This method is useful for serialization and debugging purposes.
+   *
+   * **NOTE**: If a key has multiple values, the object will contain an array of values for that key. If the key has
+   * only one value, the object will contain its value directly, without an array, regardless of how the value was
+   * initialized when creating the form data.
+   *
+   * @example
+   *   const formData = new HttpFormData<{
+   *     title: string;
+   *     descriptions: string[];
+   *     content: Blob;
+   *   }>();
+   *
+   *   formData.set('title', 'My title');
+   *   formData.append('descriptions', 'Description 1');
+   *   formData.append('descriptions', 'Description 2');
+   *   formData.set('content', new Blob(['content'], { type: 'text/plain' }));
+   *
+   *   const object = formData.toObject();
+   *   console.log(object); // { title: 'My title', descriptions: ['Description 1', 'Description 2'], content: Blob { type: 'text/plain' } }
+   *
+   * @returns A plain object representation of this form data.
+   */
+  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 !== undefined) {
+      accumulated[key] = value;
+    }
+    return accumulated;
+  }, {});
+}
+__name(pickPrimitiveProperties, "pickPrimitiveProperties");
+var HttpHeaders = class extends Headers {
+  static {
+    __name(this, "HttpHeaders");
+  }
+  constructor(init) {
+    if (init instanceof Headers || Array.isArray(init) || !init) {
+      super(init);
+    } else {
+      super(pickPrimitiveProperties(init));
+    }
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/set MDN Reference} */
+  set(name, value) {
+    super.set(name, value);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/append MDN Reference} */
+  append(name, value) {
+    super.append(name, value);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/get MDN Reference} */
+  get(name) {
+    return super.get(name);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
+  getSetCookie() {
+    return super.getSetCookie();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/has MDN Reference} */
+  has(name) {
+    return super.has(name);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/delete MDN Reference} */
+  delete(name) {
+    super.delete(name);
+  }
+  forEach(callback, thisArg) {
+    super.forEach(callback, thisArg);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/keys MDN Reference} */
+  keys() {
+    return super.keys();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/values MDN Reference} */
+  values() {
+    return super.values();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/Headers/entries MDN Reference} */
+  entries() {
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return super[Symbol.iterator]();
+  }
+  /**
+   * Checks if this headers object is equal to another set of headers. Equality is defined as having the same keys and
+   * values, regardless of the order of keys.
+   *
+   * @param otherHeaders The other headers object to compare against.
+   * @returns `true` if the headers are equal, `false` otherwise.
+   */
+  equals(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 haveCompatibleNumberOfValues = valueItems.length === otherValueItems.length;
+      if (!haveCompatibleNumberOfValues) {
+        return false;
+      }
+      for (const otherValueItem of otherValueItems) {
+        if (!valueItems.includes(otherValueItem)) {
+          return false;
+        }
+      }
+    }
+    for (const key of this.keys()) {
+      const otherHasKey = super.has.call(otherHeaders, key);
+      if (!otherHasKey) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Checks if this headers object contains another set of headers. This method is less strict than
+   * {@link HttpHeaders#equals} and only requires that all keys and values in the other headers are present in these
+   * headers.
+   *
+   * @param otherHeaders The other headers object to compare against.
+   * @returns `true` if these headers contain the other headers, `false` otherwise.
+   */
+  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 haveCompatibleNumberOfValues = valueItems.length >= otherValueItems.length;
+      if (!haveCompatibleNumberOfValues) {
+        return false;
+      }
+      for (const otherValueItem of otherValueItems) {
+        if (!valueItems.includes(otherValueItem)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Converts these headers into a plain object. This method is useful for serialization and debugging purposes.
+   *
+   * @example
+   *   const headers = new HttpHeaders({
+   *     accept: 'application/json',
+   *     'content-type': 'application/json',
+   *   });
+   *   const object = headers.toObject();
+   *   console.log(object); // { accept: 'application/json', 'content-type': 'application/json' }
+   *
+   * @returns A plain object representation of these headers.
+   */
+  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 !== undefined && !Array.isArray(value)) {
+        accumulated[key] = value;
+      }
+      return accumulated;
+    },
+    {}
+  );
+  return schemaWithPrimitiveProperties;
+}
+__name(pickPrimitiveProperties2, "pickPrimitiveProperties");
+var HttpSearchParams = class extends URLSearchParams {
+  static {
+    __name(this, "HttpSearchParams");
+  }
+  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, item);
+        }
+      }
+    }
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/set MDN Reference} */
+  set(name, value) {
+    super.set(name, value);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/append MDN Reference} */
+  append(name, value) {
+    super.append(name, value);
+  }
+  /**
+   * Get the value of the entry associated to a key name.
+   *
+   * If the key might have multiple values, use {@link HttpSearchParams#getAll} instead.
+   *
+   * @param name The name of the key to get the value of.
+   * @returns The value associated with the key name, or `null` if the key does not exist.
+   * @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/get MDN Reference}
+   */
+  get(name) {
+    return super.get(name);
+  }
+  /**
+   * Get all the values of the entry associated with a key name.
+   *
+   * If the key has at most one value, use {@link HttpSearchParams#get} instead.
+   *
+   * @param name The name of the key to get the values of.
+   * @returns An array of values associated with the key name, or an empty array if the key does not exist.
+   * @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/getAll MDN Reference}
+   */
+  getAll(name) {
+    return super.getAll(name);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/has MDN Reference} */
+  has(name, value) {
+    return super.has(name, value);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/delete MDN Reference} */
+  delete(name, value) {
+    super.delete(name, value);
+  }
+  forEach(callback, thisArg) {
+    super.forEach(callback, thisArg);
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/keys MDN Reference} */
+  keys() {
+    return super.keys();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/values MDN Reference} */
+  values() {
+    return super.values();
+  }
+  /** @see {@link https://developer.mozilla.org/docs/Web/API/URLSearchParams/entries MDN Reference} */
+  entries() {
+    return super.entries();
+  }
+  [Symbol.iterator]() {
+    return super[Symbol.iterator]();
+  }
+  /**
+   * Checks if these search params are equal to another set of search parameters. Equality is defined as having the same
+   * keys and values, regardless of the order of the keys.
+   *
+   * @param otherParams The other search parameters to compare against.
+   * @returns `true` if the search parameters are equal, `false` otherwise.
+   */
+  equals(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 this.size === otherParams.size;
+  }
+  /**
+   * Checks if these search params contain another set of search parameters. This method is less strict than
+   * {@link HttpSearchParams#equals} and only requires that all keys and values in the other search parameters are
+   * present in these search parameters.
+   *
+   * @param otherParams The other search parameters to check for containment.
+   * @returns `true` if these search parameters contain the other search parameters, `false` otherwise.
+   */
+  contains(otherParams) {
+    for (const [key, otherValue] of otherParams.entries()) {
+      const values = super.getAll.call(this, key);
+      const haveCompatibleNumberOfValues = values.length >= super.getAll.call(otherParams, key).length;
+      if (!haveCompatibleNumberOfValues) {
+        return false;
+      }
+      const valueExists = values.includes(otherValue);
+      if (!valueExists) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Converts these search params into a plain object. This method is useful for serialization and debugging purposes.
+   *
+   * **NOTE**: If a key has multiple values, the object will contain an array of values for that key. If the key has
+   * only one value, the object will contain its value directly, without an array, regardless of how the value was
+   * initialized when creating the search params object.
+   *
+   * @example
+   *   const searchParams = new HttpSearchParams({
+   *     names: ['user 1', 'user 2'],
+   *     name: ['user 3'],
+   *     page: '1',
+   *   });
+   *   const object = searchParams.toObject();
+   *   console.log(object); // { names: ['user 1', 'user 2'], name: 'user 3', page: '1' }
+   *
+   * @returns A plain object representation of these search params.
+   */
+  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_WITH_REQUEST_BODY = Object.freeze(["POST", "PUT", "PATCH", "DELETE"]);
+var HTTP_METHODS_WITH_RESPONSE_BODY = Object.freeze([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS"
+]);
+var HTTP_METHODS = Object.freeze(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+
+exports.HTTP_METHODS = HTTP_METHODS;
+exports.HTTP_METHODS_WITH_REQUEST_BODY = HTTP_METHODS_WITH_REQUEST_BODY;
+exports.HTTP_METHODS_WITH_RESPONSE_BODY = HTTP_METHODS_WITH_RESPONSE_BODY;
+exports.HttpFormData = HttpFormData_default;
+exports.HttpHeaders = HttpHeaders_default;
+exports.HttpSearchParams = HttpSearchParams_default;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map