| // pkg/dist-src/index.js |
| import { endpoint } from "@octokit/endpoint"; |
| import { getUserAgent } from "universal-user-agent"; |
| |
| // pkg/dist-src/version.js |
| var VERSION = "8.1.6"; |
| |
| // pkg/dist-src/is-plain-object.js |
| function isPlainObject(value) { |
| if (typeof value !== "object" || value === null) |
| return false; |
| if (Object.prototype.toString.call(value) !== "[object Object]") |
| return false; |
| const proto = Object.getPrototypeOf(value); |
| if (proto === null) |
| return true; |
| const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor; |
| return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value); |
| } |
| |
| // pkg/dist-src/fetch-wrapper.js |
| import { RequestError } from "@octokit/request-error"; |
| |
| // pkg/dist-src/get-buffer-response.js |
| function getBufferResponse(response) { |
| return response.arrayBuffer(); |
| } |
| |
| // pkg/dist-src/fetch-wrapper.js |
| function fetchWrapper(requestOptions) { |
| const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console; |
| const parseSuccessResponseBody = requestOptions.request?.parseSuccessResponseBody !== false; |
| if (isPlainObject(requestOptions.body) || Array.isArray(requestOptions.body)) { |
| requestOptions.body = JSON.stringify(requestOptions.body); |
| } |
| let headers = {}; |
| let status; |
| let url; |
| let { fetch } = globalThis; |
| if (requestOptions.request?.fetch) { |
| fetch = requestOptions.request.fetch; |
| } |
| if (!fetch) { |
| throw new Error( |
| "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing" |
| ); |
| } |
| return fetch(requestOptions.url, { |
| method: requestOptions.method, |
| body: requestOptions.body, |
| headers: requestOptions.headers, |
| signal: requestOptions.request?.signal, |
| // duplex must be set if request.body is ReadableStream or Async Iterables. |
| // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex. |
| ...requestOptions.body && { duplex: "half" } |
| }).then(async (response) => { |
| url = response.url; |
| status = response.status; |
| for (const keyAndValue of response.headers) { |
| headers[keyAndValue[0]] = keyAndValue[1]; |
| } |
| if ("deprecation" in headers) { |
| const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/); |
| const deprecationLink = matches && matches.pop(); |
| log.warn( |
| `[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}` |
| ); |
| } |
| if (status === 204 || status === 205) { |
| return; |
| } |
| if (requestOptions.method === "HEAD") { |
| if (status < 400) { |
| return; |
| } |
| throw new RequestError(response.statusText, status, { |
| response: { |
| url, |
| status, |
| headers, |
| data: void 0 |
| }, |
| request: requestOptions |
| }); |
| } |
| if (status === 304) { |
| throw new RequestError("Not modified", status, { |
| response: { |
| url, |
| status, |
| headers, |
| data: await getResponseData(response) |
| }, |
| request: requestOptions |
| }); |
| } |
| if (status >= 400) { |
| const data = await getResponseData(response); |
| const error = new RequestError(toErrorMessage(data), status, { |
| response: { |
| url, |
| status, |
| headers, |
| data |
| }, |
| request: requestOptions |
| }); |
| throw error; |
| } |
| return parseSuccessResponseBody ? await getResponseData(response) : response.body; |
| }).then((data) => { |
| return { |
| status, |
| url, |
| headers, |
| data |
| }; |
| }).catch((error) => { |
| if (error instanceof RequestError) |
| throw error; |
| else if (error.name === "AbortError") |
| throw error; |
| let message = error.message; |
| if (error.name === "TypeError" && "cause" in error) { |
| if (error.cause instanceof Error) { |
| message = error.cause.message; |
| } else if (typeof error.cause === "string") { |
| message = error.cause; |
| } |
| } |
| throw new RequestError(message, 500, { |
| request: requestOptions |
| }); |
| }); |
| } |
| async function getResponseData(response) { |
| const contentType = response.headers.get("content-type"); |
| if (/application\/json/.test(contentType)) { |
| return response.json().catch(() => response.text()).catch(() => ""); |
| } |
| if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) { |
| return response.text(); |
| } |
| return getBufferResponse(response); |
| } |
| function toErrorMessage(data) { |
| if (typeof data === "string") |
| return data; |
| if ("message" in data) { |
| if (Array.isArray(data.errors)) { |
| return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`; |
| } |
| return data.message; |
| } |
| return `Unknown error: ${JSON.stringify(data)}`; |
| } |
| |
| // pkg/dist-src/with-defaults.js |
| function withDefaults(oldEndpoint, newDefaults) { |
| const endpoint2 = oldEndpoint.defaults(newDefaults); |
| const newApi = function(route, parameters) { |
| const endpointOptions = endpoint2.merge(route, parameters); |
| if (!endpointOptions.request || !endpointOptions.request.hook) { |
| return fetchWrapper(endpoint2.parse(endpointOptions)); |
| } |
| const request2 = (route2, parameters2) => { |
| return fetchWrapper( |
| endpoint2.parse(endpoint2.merge(route2, parameters2)) |
| ); |
| }; |
| Object.assign(request2, { |
| endpoint: endpoint2, |
| defaults: withDefaults.bind(null, endpoint2) |
| }); |
| return endpointOptions.request.hook(request2, endpointOptions); |
| }; |
| return Object.assign(newApi, { |
| endpoint: endpoint2, |
| defaults: withDefaults.bind(null, endpoint2) |
| }); |
| } |
| |
| // pkg/dist-src/index.js |
| var request = withDefaults(endpoint, { |
| headers: { |
| "user-agent": `octokit-request.js/${VERSION} ${getUserAgent()}` |
| } |
| }); |
| export { |
| request |
| }; |