openapi-hooks/dist/index.js

Magical fetch inference for OpenAPI with React Query support

// src/index.ts
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);
  };
};
export {
  ApiError,
  createFetch
};
//# sourceMappingURL=index.js.map