@redocly/cli 2.38.0 → 2.40.0

package/lib/chunks/OYO2D2IL.js

@@ -0,0 +1,79 @@
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+import {
+  logger
+} from "./HT6ZGKQQ.js";
+
+// src/commands/split/oas/constants.ts
+var OPENAPI3_METHOD_NAMES = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace",
+  "query"
+];
+var OPENAPI3_COMPONENT_NAMES = [
+  "schemas",
+  "responses",
+  "parameters",
+  "examples",
+  "headers",
+  "requestBodies",
+  "links",
+  "callbacks",
+  "securitySchemes"
+];
+
+// src/utils/spinner.ts
+import * as process from "node:process";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner = class {
+  frames;
+  currentFrame;
+  intervalId;
+  message;
+  constructor() {
+    this.frames = SPINNER_FRAMES;
+    this.currentFrame = 0;
+    this.intervalId = null;
+    this.message = "";
+  }
+  showFrame() {
+    logger.info("\r" + this.frames[this.currentFrame] + " " + this.message);
+    this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+  }
+  start(message) {
+    if (this.message === message) {
+      return;
+    }
+    this.message = message;
+    if (!process.stderr.isTTY) {
+      logger.info(`${message}...
+`);
+      return;
+    }
+    if (this.intervalId === null) {
+      this.intervalId = setInterval(() => {
+        this.showFrame();
+      }, 100);
+    }
+  }
+  stop() {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      logger.info("\r");
+    }
+    this.message = "";
+  }
+};
+
+export {
+  OPENAPI3_METHOD_NAMES,
+  OPENAPI3_COMPONENT_NAMES,
+  Spinner
+};

package/lib/chunks/{K5FO6VRS.js → PVILCIEK.js}

@@ -8,7 +8,7 @@ import {
 } from "./4FB5ZIPP.js";
 import {
   version
-} from "./PIMMKQJ7.js";
+} from "./6DYZ77KC.js";
 import {
   require_undici
 } from "./XB6C62FW.js";
@@ -16,7 +16,7 @@ import {
   blue,
   green,
   logger
-} from "./MIPR6NCD.js";
+} from "./HT6ZGKQQ.js";
 import {
   __toESM
 } from "./5ILQMFXK.js";

package/lib/chunks/{N2TQJ4KM.js → QCV6V37L.js}

@@ -2,13 +2,13 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   RedoclyOAuthClient
-} from "./K5FO6VRS.js";
+} from "./PVILCIEK.js";
 import "./Y6DTFCLS.js";
 import "./4FB5ZIPP.js";
-import "./PIMMKQJ7.js";
+import "./6DYZ77KC.js";
 import "./XB6C62FW.js";
 import "./UUU33DK3.js";
-import "./MIPR6NCD.js";
+import "./HT6ZGKQQ.js";
 import "./Z2I5YXYN.js";
 import "./5ILQMFXK.js";
 export {

package/lib/chunks/{M5T4PDSH.js → RD4BYLLT.js}

@@ -17,7 +17,7 @@ import {
   lint,
   pluralize,
   require__
-} from "./MIPR6NCD.js";
+} from "./HT6ZGKQQ.js";
 import {
   __commonJS,
   __toESM

package/lib/chunks/TYUOO44G.js

@@ -0,0 +1,492 @@
+import { createRequire as __createRequire } from 'node:module';
+const require = __createRequire(import.meta.url);
+import {
+  isPlainObject
+} from "./HT6ZGKQQ.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-amzn-trace-id",
+  "x-client-trace-id",
+  "x-cloud-trace-context",
+  "x-correlation-id",
+  "x-http-method-override",
+  "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-b3-",
+  "x-envoy-",
+  "x-forwarded-"
+];
+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
+};