@redocly/cli 2.41.2 → 2.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/cli",
-  "version": "2.41.2",
+  "version": "2.42.0",
   "description": "",
   "license": "MIT",
   "type": "module",

package/lib/chunks/3CX2Z7JI.js

@@ -1,496 +0,0 @@
-import { createRequire as __createRequire } from 'node:module';
-const require = __createRequire(import.meta.url);
-import {
-  isPlainObject
-} from "./Z2664VV5.js";
-
-// src/commands/drift/utils/files.ts
-import { open, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-var SPEC_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".json"]);
-async function listOpenApiFiles(rootDir) {
-  const output = [];
-  async function walk(currentDir) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const absolutePath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(absolutePath);
-        continue;
-      }
-      if (entry.isFile() && SPEC_FILE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
-        output.push(absolutePath);
-      }
-    }
-  }
-  await walk(rootDir);
-  output.sort();
-  return output;
-}
-async function readProbe(filePath, maxBytes = 4096) {
-  const fileHandle = await open(filePath, "r");
-  try {
-    const buffer = Buffer.allocUnsafe(maxBytes);
-    const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
-    return buffer.toString("utf8", 0, bytesRead);
-  } finally {
-    await fileHandle.close();
-  }
-}
-function normalizeFsPath(value) {
-  return path.resolve(process.cwd(), value);
-}
-async function listFilesRecursively(rootPath) {
-  const stats = await stat(rootPath);
-  if (stats.isFile()) {
-    return [rootPath];
-  }
-  if (!stats.isDirectory()) {
-    return [];
-  }
-  const output = [];
-  async function walk(currentDir) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const absolutePath = path.join(currentDir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(absolutePath);
-        continue;
-      }
-      if (entry.isFile()) {
-        output.push(absolutePath);
-      }
-    }
-  }
-  await walk(rootPath);
-  output.sort();
-  return output;
-}
-
-// src/commands/drift/utils/http.ts
-var DUMMY_HOST = "drift.local";
-var DUMMY_BASE_URL = `http://${DUMMY_HOST}`;
-function isSyntheticHost(host) {
-  return host === DUMMY_HOST;
-}
-var IGNORED_UNDOCUMENTED_HEADERS = /* @__PURE__ */ new Set([
-  "accept",
-  "accept-charset",
-  "accept-encoding",
-  "accept-language",
-  "authorization",
-  "baggage",
-  "cache-control",
-  "cdn-loop",
-  "cookie",
-  "connection",
-  "content-length",
-  "content-type",
-  "dpr",
-  "dnt",
-  "downlink",
-  "ect",
-  "forwarded",
-  "host",
-  "if-match",
-  "if-modified-since",
-  "if-none-match",
-  "if-range",
-  "if-unmodified-since",
-  "origin",
-  "pragma",
-  "priority",
-  "range",
-  "referer",
-  "sec-fetch-dest",
-  "sec-fetch-mode",
-  "sec-fetch-site",
-  "sec-fetch-user",
-  "sec-gpc",
-  "sentry-trace",
-  "te",
-  "traceparent",
-  "tracestate",
-  "upgrade",
-  "upgrade-insecure-requests",
-  "user-agent",
-  "via",
-  "x-client-trace-id",
-  "x-cloud-trace-context",
-  "x-correlation-id",
-  "x-http-method-override",
-  "x-hub-signature",
-  "x-hub-signature-256",
-  "x-method-override",
-  "x-real-ip",
-  "x-request-id",
-  "x-forwarded-for",
-  "x-forwarded-host",
-  "x-forwarded-port",
-  "x-forwarded-proto"
-]);
-var IGNORED_UNDOCUMENTED_HEADER_PREFIXES = [
-  "cf-",
-  "sec-ch-",
-  "sec-fetch-",
-  "x-amz-",
-  "x-amzn-",
-  "x-b3-",
-  "x-envoy-",
-  "x-forwarded-",
-  "x-github-"
-];
-var SET_COOKIE_SEPARATOR = "\n";
-function splitSetCookieHeader(value) {
-  return value.split(SET_COOKIE_SEPARATOR);
-}
-function appendHeaderValue(result, name, value) {
-  const key = name.toLowerCase();
-  const existing = result[key];
-  if (existing === void 0) {
-    result[key] = value;
-    return;
-  }
-  result[key] = key === "set-cookie" ? `${existing}${SET_COOKIE_SEPARATOR}${value}` : `${existing},${value}`;
-}
-function normalizeHeaders(input) {
-  if (!isPlainObject(input) && !Array.isArray(input)) {
-    return {};
-  }
-  const result = {};
-  if (Array.isArray(input)) {
-    for (const item of input) {
-      if (!isPlainObject(item)) {
-        continue;
-      }
-      const { name, value } = item;
-      if (typeof name === "string" && value !== void 0) {
-        appendHeaderValue(result, name, String(value));
-      }
-    }
-    return result;
-  }
-  for (const [key, value] of Object.entries(input)) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        appendHeaderValue(result, key, String(item));
-      }
-      continue;
-    }
-    appendHeaderValue(result, key, String(value));
-  }
-  return result;
-}
-function parseUrl(input) {
-  try {
-    return new URL(input);
-  } catch {
-    return new URL(input, DUMMY_BASE_URL);
-  }
-}
-function getPathWithoutTrailingSlash(pathname) {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.slice(0, -1);
-  }
-  return pathname;
-}
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function compileOpenApiPath(pathTemplate) {
-  const params = [];
-  let score = 0;
-  const absolutePath = pathTemplate.startsWith("/") ? pathTemplate : `/${pathTemplate}`;
-  const normalizedPath = getPathWithoutTrailingSlash(absolutePath);
-  const regexBody = normalizedPath.split("/").map((segment) => {
-    if (!segment) {
-      return "";
-    }
-    const paramMatch = segment.match(/^\{([^}]+)\}$/);
-    if (paramMatch) {
-      params.push(paramMatch[1]);
-      return "([^/]+)";
-    }
-    score += 2;
-    return escapeRegex(segment);
-  }).join("/");
-  return {
-    regex: new RegExp(`^${regexBody || "/"}$`),
-    params,
-    score
-  };
-}
-function parseJsonBodyIfPresent(contentType, bodyText) {
-  if (!bodyText) {
-    return void 0;
-  }
-  if (!isJsonMime(contentType)) {
-    return void 0;
-  }
-  try {
-    return JSON.parse(bodyText);
-  } catch {
-    return void 0;
-  }
-}
-function normalizeContentType(contentType) {
-  if (!contentType) {
-    return "";
-  }
-  return contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-}
-function isJsonMime(contentType) {
-  const mime = normalizeContentType(contentType);
-  return mime === "application/json" || mime.endsWith("+json");
-}
-function pickSchemaByMime(contentMap, contentType) {
-  const requestedMime = normalizeContentType(contentType);
-  if (!requestedMime) {
-    return contentMap["application/json"] ?? contentMap["*/*"];
-  }
-  if (contentMap[requestedMime] !== void 0) {
-    return contentMap[requestedMime];
-  }
-  const [type, subtype] = requestedMime.split("/");
-  if (type && subtype) {
-    const wildcardSubtype = `${type}/*`;
-    if (contentMap[wildcardSubtype] !== void 0) {
-      return contentMap[wildcardSubtype];
-    }
-  }
-  return contentMap["*/*"];
-}
-function parseHeaderIgnoreList(patterns) {
-  const names = /* @__PURE__ */ new Set();
-  const prefixes = [];
-  for (const pattern of patterns) {
-    const normalized = pattern.trim().toLowerCase();
-    if (normalized.length === 0) {
-      continue;
-    }
-    if (normalized.endsWith("*")) {
-      prefixes.push(normalized.slice(0, -1));
-    } else {
-      names.add(normalized);
-    }
-  }
-  return { names, prefixes };
-}
-function shouldIgnoreHeaderAsUndocumented(headerName, extraIgnored) {
-  const normalizedHeaderName = headerName.toLowerCase();
-  if (normalizedHeaderName.startsWith(":")) {
-    return true;
-  }
-  if (IGNORED_UNDOCUMENTED_HEADERS.has(normalizedHeaderName) || IGNORED_UNDOCUMENTED_HEADER_PREFIXES.some((prefix) => normalizedHeaderName.startsWith(prefix))) {
-    return true;
-  }
-  if (extraIgnored) {
-    return extraIgnored.names.has(normalizedHeaderName) || extraIgnored.prefixes.some((prefix) => normalizedHeaderName.startsWith(prefix));
-  }
-  return false;
-}
-
-// src/commands/drift/log-formats/helpers.ts
-import { createReadStream } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { createInterface } from "node:readline";
-function coerceString(value) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (Buffer.isBuffer(value)) {
-    return value.toString("utf8");
-  }
-  if (isPlainObject(value) || Array.isArray(value)) {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
-  }
-  return String(value);
-}
-function coerceNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function decodeBody(value, encoding) {
-  if (value === void 0 || value === null) {
-    return void 0;
-  }
-  if (encoding === "base64" && typeof value === "string") {
-    try {
-      return Buffer.from(value, "base64").toString("utf8");
-    } catch {
-      return value;
-    }
-  }
-  return coerceString(value);
-}
-function createNormalizedExchange(seed, index, source) {
-  const method = seed.method?.toUpperCase();
-  const url = seed.url;
-  if (!method || !url) {
-    return null;
-  }
-  const requestHeaders = normalizeHeaders(seed.requestHeaders);
-  let parsedUrl = parseUrl(url);
-  if (isSyntheticHost(parsedUrl.host) && requestHeaders.host) {
-    try {
-      parsedUrl = new URL(
-        `${parsedUrl.protocol}//${requestHeaders.host}${parsedUrl.pathname}${parsedUrl.search}`
-      );
-    } catch {
-      parsedUrl = parseUrl(url);
-    }
-  }
-  const requestContentType = seed.requestContentType ?? requestHeaders["content-type"];
-  const requestBodyText = decodeBody(seed.requestBody);
-  const request = {
-    method,
-    url: parsedUrl.toString(),
-    path: parsedUrl.pathname,
-    query: parsedUrl.searchParams,
-    protocol: parsedUrl.protocol,
-    protocolKnown: seed.schemeKnown ?? /^https?:\/\//i.test(url),
-    host: isSyntheticHost(parsedUrl.host) ? void 0 : parsedUrl.host || void 0,
-    headers: requestHeaders,
-    contentType: requestContentType,
-    bodyText: requestBodyText,
-    bodyJson: parseJsonBodyIfPresent(requestContentType, requestBodyText)
-  };
-  let response;
-  const responseStatus = seed.responseStatus;
-  if (responseStatus !== void 0) {
-    const responseHeaders = normalizeHeaders(seed.responseHeaders);
-    const responseContentType = seed.responseContentType ?? responseHeaders["content-type"];
-    const responseBodyText = decodeBody(seed.responseBody);
-    response = {
-      status: responseStatus,
-      statusText: seed.responseStatusText,
-      headers: responseHeaders,
-      contentType: responseContentType,
-      bodyText: responseBodyText,
-      bodyJson: parseJsonBodyIfPresent(responseContentType, responseBodyText)
-    };
-  }
-  return {
-    index,
-    source,
-    startedAt: seed.startedAt,
-    request,
-    response,
-    raw: seed.raw
-  };
-}
-async function* streamNdjsonObjects(filePath) {
-  const readStream = createReadStream(filePath, { encoding: "utf8" });
-  const reader = createInterface({ input: readStream, crlfDelay: Infinity });
-  for await (const line of reader) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (isPlainObject(parsed)) {
-        yield parsed;
-      }
-    } catch {
-    }
-  }
-}
-async function* iterateJsonArray(filePath, arrayPath) {
-  const content = await readFile(filePath, "utf8");
-  let value = JSON.parse(content);
-  if (arrayPath) {
-    for (const key of arrayPath.split(".")) {
-      value = isPlainObject(value) ? value[key] : void 0;
-    }
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (isPlainObject(item)) {
-        yield item;
-      }
-    }
-  }
-}
-function pickHeaderContentType(headers) {
-  const normalized = normalizeHeaders(headers);
-  return normalized["content-type"];
-}
-
-// src/commands/drift/utils/server.ts
-function normalizeServerPrefix(server) {
-  const trimmed = server?.replace(/\/+$/, "");
-  return trimmed || void 0;
-}
-function stripPrefixFromPath(pathname, prefixPath) {
-  if (!prefixPath || prefixPath === "/") {
-    return pathname || "/";
-  }
-  if (pathname === prefixPath) {
-    return "/";
-  }
-  if (!pathname.startsWith(`${prefixPath}/`)) {
-    return void 0;
-  }
-  return pathname.slice(prefixPath.length) || "/";
-}
-function resolvePathForServer(request, server) {
-  if (server.startsWith("/")) {
-    return stripPrefixFromPath(request.path, server);
-  }
-  const serverUrl = parseUrl(server.includes("://") ? server : `http://${server}`);
-  if (isSyntheticHost(serverUrl.host) || request.host !== void 0 && request.host.toLowerCase() !== serverUrl.host) {
-    return void 0;
-  }
-  return stripPrefixFromPath(request.path, getPathWithoutTrailingSlash(serverUrl.pathname));
-}
-
-export {
-  listOpenApiFiles,
-  readProbe,
-  normalizeFsPath,
-  listFilesRecursively,
-  isSyntheticHost,
-  splitSetCookieHeader,
-  parseUrl,
-  getPathWithoutTrailingSlash,
-  compileOpenApiPath,
-  normalizeContentType,
-  isJsonMime,
-  pickSchemaByMime,
-  parseHeaderIgnoreList,
-  shouldIgnoreHeaderAsUndocumented,
-  coerceString,
-  coerceNumber,
-  decodeBody,
-  createNormalizedExchange,
-  streamNdjsonObjects,
-  iterateJsonArray,
-  pickHeaderContentType,
-  normalizeServerPrefix,
-  resolvePathForServer
-};