nuxi
Version:
Nuxt CLI
284 lines (283 loc) • 11.3 kB
JavaScript
import { i as withQuery, r as withBase, t as destr } from "./dist-n2x8nSvK.mjs";
import { o as n$1 } from "./dist-BPzTdxaO.mjs";
import { i as require_semver } from "./versions-Bq8QDcwV.mjs";
import { c as ye, n as Mn, t as Mi } from "./node-BvhbmuE6.mjs";
import nodeHTTP from "node:http";
import nodeHTTPS from "node:https";
//#region ../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/index.mjs
const o = !!globalThis.process?.env?.FORCE_NODE_FETCH, r$1 = !o && globalThis.fetch || Mi;
!o && globalThis.Blob;
!o && globalThis.File;
!o && globalThis.FormData;
const n = !o && globalThis.Headers || ye;
!o && globalThis.Request;
!o && globalThis.Response;
const T = !o && globalThis.AbortController || Mn;
//#endregion
//#region ../../node_modules/.pnpm/ofetch@1.5.1/node_modules/ofetch/dist/shared/ofetch.CWycOUEr.mjs
var FetchError = class extends Error {
constructor(message, opts) {
super(message, opts);
this.name = "FetchError";
if (opts?.cause && !this.cause) this.cause = opts.cause;
}
};
function createFetchError(ctx) {
const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
const method = ctx.request?.method || ctx.options?.method || "GET";
const url = ctx.request?.url || String(ctx.request) || "/";
const fetchError = new FetchError(`${`[${method}] ${JSON.stringify(url)}`}: ${ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>"}${errorMessage ? ` ${errorMessage}` : ""}`, ctx.error ? { cause: ctx.error } : void 0);
for (const key of [
"request",
"options",
"response"
]) Object.defineProperty(fetchError, key, { get() {
return ctx[key];
} });
for (const [key, refKey] of [
["data", "_data"],
["status", "status"],
["statusCode", "status"],
["statusText", "statusText"],
["statusMessage", "statusText"]
]) Object.defineProperty(fetchError, key, { get() {
return ctx.response && ctx.response[refKey];
} });
return fetchError;
}
const payloadMethods = new Set(Object.freeze([
"PATCH",
"POST",
"PUT",
"DELETE"
]));
function isPayloadMethod(method = "GET") {
return payloadMethods.has(method.toUpperCase());
}
function isJSONSerializable(value) {
if (value === void 0) return false;
const t = typeof value;
if (t === "string" || t === "number" || t === "boolean" || t === null) return true;
if (t !== "object") return false;
if (Array.isArray(value)) return true;
if (value.buffer) return false;
if (value instanceof FormData || value instanceof URLSearchParams) return false;
return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
}
const textTypes = /* @__PURE__ */ new Set([
"image/svg",
"application/xml",
"application/xhtml",
"application/html"
]);
const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
function detectResponseType(_contentType = "") {
if (!_contentType) return "json";
const contentType = _contentType.split(";").shift() || "";
if (JSON_RE.test(contentType)) return "json";
if (contentType === "text/event-stream") return "stream";
if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
return "blob";
}
function resolveFetchOptions(request, input, defaults, Headers) {
const headers = mergeHeaders(input?.headers ?? request?.headers, defaults?.headers, Headers);
let query;
if (defaults?.query || defaults?.params || input?.params || input?.query) query = {
...defaults?.params,
...defaults?.query,
...input?.params,
...input?.query
};
return {
...defaults,
...input,
query,
params: query,
headers
};
}
function mergeHeaders(input, defaults, Headers) {
if (!defaults) return new Headers(input);
const headers = new Headers(defaults);
if (input) for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) headers.set(key, value);
return headers;
}
async function callHooks(context, hooks) {
if (hooks) if (Array.isArray(hooks)) for (const hook of hooks) await hook(context);
else await hooks(context);
}
const retryStatusCodes = /* @__PURE__ */ new Set([
408,
409,
425,
429,
500,
502,
503,
504
]);
const nullBodyResponses = /* @__PURE__ */ new Set([
101,
204,
205,
304
]);
function createFetch(globalOptions = {}) {
const { fetch = globalThis.fetch, Headers = globalThis.Headers, AbortController = globalThis.AbortController } = globalOptions;
async function onError(context) {
const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
if (context.options.retry !== false && !isAbort) {
let retries;
if (typeof context.options.retry === "number") retries = context.options.retry;
else retries = isPayloadMethod(context.options.method) ? 0 : 1;
const responseCode = context.response && context.response.status || 500;
if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
if (retryDelay > 0) await new Promise((resolve) => setTimeout(resolve, retryDelay));
return $fetchRaw(context.request, {
...context.options,
retry: retries - 1
});
}
}
const error = createFetchError(context);
if (Error.captureStackTrace) Error.captureStackTrace(error, $fetchRaw);
throw error;
}
const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
const context = {
request: _request,
options: resolveFetchOptions(_request, _options, globalOptions.defaults, Headers),
response: void 0,
error: void 0
};
if (context.options.method) context.options.method = context.options.method.toUpperCase();
if (context.options.onRequest) {
await callHooks(context, context.options.onRequest);
if (!(context.options.headers instanceof Headers)) context.options.headers = new Headers(context.options.headers || {});
}
if (typeof context.request === "string") {
if (context.options.baseURL) context.request = withBase(context.request, context.options.baseURL);
if (context.options.query) {
context.request = withQuery(context.request, context.options.query);
delete context.options.query;
}
if ("query" in context.options) delete context.options.query;
if ("params" in context.options) delete context.options.params;
}
if (context.options.body && isPayloadMethod(context.options.method)) {
if (isJSONSerializable(context.options.body)) {
const contentType = context.options.headers.get("content-type");
if (typeof context.options.body !== "string") context.options.body = contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(context.options.body).toString() : JSON.stringify(context.options.body);
if (!contentType) context.options.headers.set("content-type", "application/json");
if (!context.options.headers.has("accept")) context.options.headers.set("accept", "application/json");
} else if ("pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || typeof context.options.body.pipe === "function") {
if (!("duplex" in context.options)) context.options.duplex = "half";
}
}
let abortTimeout;
if (!context.options.signal && context.options.timeout) {
const controller = new AbortController();
abortTimeout = setTimeout(() => {
const error = /* @__PURE__ */ new Error("[TimeoutError]: The operation was aborted due to timeout");
error.name = "TimeoutError";
error.code = 23;
controller.abort(error);
}, context.options.timeout);
context.options.signal = controller.signal;
}
try {
context.response = await fetch(context.request, context.options);
} catch (error) {
context.error = error;
if (context.options.onRequestError) await callHooks(context, context.options.onRequestError);
return await onError(context);
} finally {
if (abortTimeout) clearTimeout(abortTimeout);
}
if ((context.response.body || context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD") {
const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
switch (responseType) {
case "json": {
const data = await context.response.text();
const parseFunction = context.options.parseResponse || destr;
context.response._data = parseFunction(data);
break;
}
case "stream":
context.response._data = context.response.body || context.response._bodyInit;
break;
default: context.response._data = await context.response[responseType]();
}
}
if (context.options.onResponse) await callHooks(context, context.options.onResponse);
if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
if (context.options.onResponseError) await callHooks(context, context.options.onResponseError);
return await onError(context);
}
return context.response;
};
const $fetch = async function $fetch2(request, options) {
return (await $fetchRaw(request, options))._data;
};
$fetch.raw = $fetchRaw;
$fetch.native = (...args) => fetch(...args);
$fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
...globalOptions,
...customGlobalOptions,
defaults: {
...globalOptions.defaults,
...customGlobalOptions.defaults,
...defaultOptions
}
});
return $fetch;
}
//#endregion
//#region ../../node_modules/.pnpm/ofetch@1.5.1/node_modules/ofetch/dist/node.mjs
function createNodeFetch() {
if (!JSON.parse(process.env.FETCH_KEEP_ALIVE || "false")) return r$1;
const agentOptions = { keepAlive: true };
const httpAgent = new nodeHTTP.Agent(agentOptions);
const httpsAgent = new nodeHTTPS.Agent(agentOptions);
const nodeFetchOptions = { agent(parsedURL) {
return parsedURL.protocol === "http:" ? httpAgent : httpsAgent;
} };
return function nodeFetchWithKeepAlive(input, init) {
return r$1(input, {
...nodeFetchOptions,
...init
});
};
}
const $fetch = createFetch({
fetch: globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch(),
Headers: globalThis.Headers || n,
AbortController: globalThis.AbortController || T
});
//#endregion
//#region src/commands/module/_utils.ts
var import_semver = require_semver();
async function fetchModules() {
const { modules } = await $fetch(`https://api.nuxt.com/modules?version=all`);
return modules;
}
function checkNuxtCompatibility(module, nuxtVersion) {
if (!module.compatibility?.nuxt) return true;
return (0, import_semver.satisfies)(nuxtVersion, module.compatibility.nuxt, { includePrerelease: true });
}
function getRegistryFromContent(content, scope) {
try {
const npmConfig = n$1(content);
if (scope) {
const scopeKey = `${scope}:registry`;
if (npmConfig[scopeKey]) return npmConfig[scopeKey].trim();
}
if (npmConfig.registry) return npmConfig.registry.trim();
return null;
} catch {
return null;
}
}
//#endregion
export { $fetch as i, fetchModules as n, getRegistryFromContent as r, checkNuxtCompatibility as t };