openapi-hooks/dist/index.cjs

Magical fetch inference for OpenAPI with React Query support

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  ApiError: () => ApiError,
  createFetch: () => createFetch
});
module.exports = __toCommonJS(index_exports);
var ApiError = class _ApiError extends Error {
  // eslint-disable-next-line unused-imports/no-unused-vars
  constructor(message, status) {
    super(message);
    this.status = status;
  }
  static fromResponse(response) {
    return new _ApiError(response.statusText, response.status);
  }
};
var convertBody = (data, contentType) => {
  if (contentType === void 0) {
    return;
  }
  switch (contentType) {
    case "application/json":
    case "application/json; charset=utf-8":
      return JSON.stringify(data);
    default:
      throw new Error("Unsupported content type: " + contentType);
  }
};
var decodeResponse = async (response, responseContentType) => {
  switch (responseContentType) {
    // eslint-disable-next-line unicorn/no-null
    case null:
      return {
        status: response.status,
        headers: response.headers
      };
    case "text/plain; charset=utf-8":
      return {
        status: response.status,
        contentType: responseContentType,
        data: await response.text()
      };
    case "application/json; charset=utf-8":
      return {
        status: response.status,
        contentType: responseContentType,
        data: await response.json(),
        headers: response.headers
      };
    default:
      throw new Error("Unsupported content type: " + responseContentType);
  }
};
var createFetch = (options) => {
  const { baseUrl = window.location.toString(), headers: defaultHeaders, onError } = options ?? {};
  return async (path, method, options2) => {
    const {
      query,
      header,
      path: pathParameters,
      contentType,
      data,
      fetchOptions
    } = options2;
    if (pathParameters) {
      for (const [key, value] of Object.entries(pathParameters)) {
        path = path.toString().replace(`{${key}}`, value);
      }
    }
    const url = new URL(`.${path.toString()}`, baseUrl);
    if (query) {
      for (const [key, value] of Object.entries(query)) {
        if (!value) continue;
        url.searchParams.set(key, value.toString());
      }
    }
    const headers = new Headers();
    if (defaultHeaders) {
      let addDefaultHeaders = typeof defaultHeaders === "function" ? await defaultHeaders() : defaultHeaders;
      for (const [key, value] of Object.entries(addDefaultHeaders)) {
        headers.set(key, value);
      }
    }
    if (contentType) {
      headers.set("Content-Type", contentType);
    }
    if (header) {
      for (const [key, value] of Object.entries(header)) {
        headers.set(key, value.toString());
      }
    }
    const response = await fetch(url, {
      method: method.toUpperCase(),
      headers,
      body: convertBody(data, contentType),
      ...fetchOptions
    });
    if (!response.ok) {
      onError?.(ApiError.fromResponse(response));
      throw ApiError.fromResponse(response);
    }
    const responseContentType = response.headers.get("content-type");
    return await decodeResponse(response, responseContentType);
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ApiError,
  createFetch
});
//# sourceMappingURL=index.cjs.map