@scalar/api-client 2.38.4 → 2.39.0

package/dist/v2/features/command-palette/helpers/get-openapi-from-postman.d.ts

@@ -1,3 +1,4 @@
+import { type ConvertOptions } from '@scalar/postman-to-openapi';
 /**
  * Converts a Postman collection JSON string to an OpenAPI specification document.
  *
@@ -7,7 +8,7 @@
  *
  * Returns null if the conversion fails due to invalid Postman collection structure
  */
-export declare const getOpenApiFromPostman: (postmanJson: string) => (Omit<Omit<import("@scalar/openapi-types").OpenAPIV3.Document<{}>, "components" | "paths">, keyof {
+export declare const getOpenApiFromPostman: (postmanJson: string, convertOptions?: ConvertOptions) => (Omit<Omit<import("@scalar/openapi-types").OpenAPIV3.Document<{}>, "components" | "paths">, keyof {
     [customExtension: `x-${string}`]: any;
     [key: string]: any;
 }> & {

package/dist/v2/features/command-palette/helpers/get-openapi-from-postman.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-openapi-from-postman.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-openapi-from-postman.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM;;;;;;;;;;;;SAOxD,CAAA"}
+{"version":3,"file":"get-openapi-from-postman.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-openapi-from-postman.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAW,MAAM,4BAA4B,CAAA;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,EAAE,iBAAiB,cAAc;;;;;;;;;;;;SAMzF,CAAA"}

package/dist/v2/features/command-palette/helpers/get-openapi-from-postman.js

@@ -0,0 +1,22 @@
+import { convert } from "@scalar/postman-to-openapi";
+//#region src/v2/features/command-palette/helpers/get-openapi-from-postman.ts
+/**
+* Converts a Postman collection JSON string to an OpenAPI specification document.
+*
+* This function transforms a Postman collection into a valid OpenAPI 3.1 document
+* that can be used throughout the application. The convert function handles parsing
+* and transformation internally.
+*
+* Returns null if the conversion fails due to invalid Postman collection structure
+*/
+var getOpenApiFromPostman = (postmanJson, convertOptions) => {
+	try {
+		return convert(postmanJson, convertOptions);
+	} catch {
+		return null;
+	}
+};
+//#endregion
+export { getOpenApiFromPostman };
+
+//# sourceMappingURL=get-openapi-from-postman.js.map

package/dist/v2/features/command-palette/helpers/get-openapi-from-postman.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-openapi-from-postman.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/get-openapi-from-postman.ts"],"sourcesContent":["import { type ConvertOptions, convert } from '@scalar/postman-to-openapi'\n\n/**\n * Converts a Postman collection JSON string to an OpenAPI specification document.\n *\n * This function transforms a Postman collection into a valid OpenAPI 3.1 document\n * that can be used throughout the application. The convert function handles parsing\n * and transformation internally.\n *\n * Returns null if the conversion fails due to invalid Postman collection structure\n */\nexport const getOpenApiFromPostman = (postmanJson: string, convertOptions?: ConvertOptions) => {\n  try {\n    return convert(postmanJson, convertOptions)\n  } catch {\n    return null\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,IAAa,yBAAyB,aAAqB,mBAAoC;AAC7F,KAAI;AACF,SAAO,QAAQ,aAAa,eAAe;SACrC;AACN,SAAO"}

package/dist/v2/features/command-palette/helpers/get-operation-from-curl.js

@@ -0,0 +1,119 @@
+import { parseCurlCommand } from "../../../../libs/parse-curl.js";
+//#region src/v2/features/command-palette/helpers/get-operation-from-curl.ts
+/**
+* Parses request body data from a string.
+* Attempts JSON parsing first, then falls back to form-encoded parsing.
+*
+* Form-encoded data is expected in the format: key1=value1&key2=value2
+*/
+var parseRequestBodyData = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		const result = {};
+		data.split("&").forEach((pair) => {
+			const [key, value] = pair.split("=");
+			if (key && value) result[decodeURIComponent(key)] = decodeURIComponent(value);
+		});
+		return result;
+	}
+};
+/**
+* Determines the content type based on the request body structure.
+* Returns form-encoded if the body looks like form data, JSON if the body looks like JSON,
+* otherwise uses the header value.
+*/
+var detectContentType = (body, headers) => {
+	if (headers["Content-Type"]) return headers["Content-Type"];
+	const trimmedBody = body.trim();
+	if (trimmedBody.startsWith("{") || trimmedBody.startsWith("[")) return "application/json";
+	return body.includes("=") && !trimmedBody.startsWith("{") ? "application/x-www-form-urlencoded" : "";
+};
+/**
+* Infers a JSON Schema type from a JavaScript value.
+* Maps JavaScript typeof results to JSON Schema primitive types.
+*/
+var inferSchemaType = (value) => {
+	const jsType = typeof value;
+	if (jsType === "string") return "string";
+	if (jsType === "number") return "number";
+	if (jsType === "boolean") return "boolean";
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (jsType === "object") return "object";
+	return "string";
+};
+/**
+* Creates query and header parameters from parsed cURL data.
+* Each parameter includes a schema with inferred type and an example value.
+*/
+var createParameters = (queryParameters, headers, exampleKey) => {
+	const queryParams = Array.isArray(queryParameters) ? queryParameters.map(({ key, value }) => ({
+		name: key,
+		in: "query",
+		schema: { type: inferSchemaType(value) },
+		examples: { [exampleKey]: { value } }
+	})) : [];
+	const headerParams = Object.entries(headers || {}).map(([key, value]) => ({
+		name: key,
+		in: "header",
+		schema: { type: inferSchemaType(value) },
+		examples: { [exampleKey]: { value } }
+	}));
+	return [...queryParams, ...headerParams];
+};
+/**
+* Creates a request body schema from parsed data.
+* Generates an object schema with properties inferred from the data structure.
+*/
+var createRequestBodySchema = (data) => {
+	return {
+		type: "object",
+		properties: Object.fromEntries(Object.entries(data).map(([key, value]) => [key, { type: inferSchemaType(value) }]))
+	};
+};
+/** Don't want to throw for invalid URLs */
+var safePathname = (url) => {
+	try {
+		return new URL(url).pathname;
+	} catch {
+		return "/";
+	}
+};
+/**
+* Converts a cURL command string into an OpenAPI operation object.
+*
+* This function parses a cURL command and extracts all relevant information
+* (path, method, headers, query parameters, request body) to create a complete
+* OpenAPI operation that can be used to populate a request in the API client.
+*
+* The exampleKey is used to namespace the example values in the operation object,
+* allowing multiple examples to coexist if needed.
+*/
+var getOperationFromCurl = (curl, exampleKey = "curl") => {
+	const { method = "get", url, body = "", headers = {}, servers = [], queryParameters = [] } = parseCurlCommand(curl);
+	const path = safePathname(url);
+	const contentType = detectContentType(body, headers);
+	const requestBodyData = body ? parseRequestBodyData(body) : {};
+	const parameters = createParameters(queryParameters, headers, exampleKey);
+	const serverObjects = servers.map((server) => ({ url: server }));
+	return {
+		path,
+		method,
+		operation: {
+			parameters,
+			requestBody: {
+				content: { [contentType]: {
+					schema: createRequestBodySchema(requestBodyData),
+					examples: { [exampleKey]: { value: requestBodyData } }
+				} },
+				"x-scalar-selected-content-type": { [exampleKey]: contentType }
+			},
+			servers: serverObjects.length ? serverObjects : void 0
+		}
+	};
+};
+//#endregion
+export { getOperationFromCurl };
+
+//# sourceMappingURL=get-operation-from-curl.js.map

package/dist/v2/features/command-palette/helpers/get-operation-from-curl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-operation-from-curl.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/get-operation-from-curl.ts"],"sourcesContent":["import type { HttpMethod } from '@scalar/helpers/http/http-methods'\nimport type {\n  OperationObject,\n  ParameterObject,\n  SchemaObject,\n  ServerObject,\n} from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { parseCurlCommand } from '@/libs'\n\n/**\n * Represents the result of parsing a cURL command into an OpenAPI operation.\n */\ntype CurlOperationResult = {\n  /** The URL path extracted from the cURL command. */\n  path: string\n  /** The HTTP method (GET, POST, etc.). */\n  method: HttpMethod\n  /** The OpenAPI operation object with parameters, body, and servers. */\n  operation: OperationObject\n}\n\n/**\n * Represents data that can be either JSON or form-encoded key-value pairs.\n */\ntype ParsedData = Record<string, unknown>\n\n/**\n * Parses request body data from a string.\n * Attempts JSON parsing first, then falls back to form-encoded parsing.\n *\n * Form-encoded data is expected in the format: key1=value1&key2=value2\n */\nconst parseRequestBodyData = (data: string): ParsedData => {\n  try {\n    // Try parsing as JSON first\n    return JSON.parse(data) as ParsedData\n  } catch {\n    // If JSON parsing fails, parse as form-encoded data (key=value&key2=value2)\n    const result: Record<string, string> = {}\n\n    data.split('&').forEach((pair) => {\n      const [key, value] = pair.split('=')\n      if (key && value) {\n        result[decodeURIComponent(key)] = decodeURIComponent(value)\n      }\n    })\n\n    return result\n  }\n}\n\n/**\n * Determines the content type based on the request body structure.\n * Returns form-encoded if the body looks like form data, JSON if the body looks like JSON,\n * otherwise uses the header value.\n */\nconst detectContentType = (body: string, headers: Record<string, string>): string => {\n  // If Content-Type header is explicitly provided, use it\n  if (headers['Content-Type']) {\n    return headers['Content-Type']\n  }\n\n  // Check if body looks like JSON (starts with { or [)\n  const trimmedBody = body.trim()\n  const isJson = trimmedBody.startsWith('{') || trimmedBody.startsWith('[')\n\n  if (isJson) {\n    return 'application/json'\n  }\n\n  // Check if body looks like form-encoded data (contains = but does not start with {)\n  const isFormEncoded = body.includes('=') && !trimmedBody.startsWith('{')\n\n  return isFormEncoded ? 'application/x-www-form-urlencoded' : ''\n}\n\n/**\n * Infers a JSON Schema type from a JavaScript value.\n * Maps JavaScript typeof results to JSON Schema primitive types.\n */\nconst inferSchemaType = (value: unknown): string => {\n  const jsType = typeof value\n\n  // Map JavaScript types to JSON Schema types\n  if (jsType === 'string') {\n    return 'string'\n  }\n  if (jsType === 'number') {\n    return 'number'\n  }\n  if (jsType === 'boolean') {\n    return 'boolean'\n  }\n  if (value === null) {\n    return 'null'\n  }\n  if (Array.isArray(value)) {\n    return 'array'\n  }\n  if (jsType === 'object') {\n    return 'object'\n  }\n\n  // Default fallback for any other types\n  return 'string'\n}\n\n/**\n * Creates query and header parameters from parsed cURL data.\n * Each parameter includes a schema with inferred type and an example value.\n */\nconst createParameters = (\n  queryParameters: Array<{ key: string; value: string }>,\n  headers: Record<string, string>,\n  exampleKey: string,\n): ParameterObject[] => {\n  const queryParams = Array.isArray(queryParameters)\n    ? queryParameters.map(({ key, value }) => ({\n        name: key,\n        in: 'query' as const,\n        schema: { type: inferSchemaType(value) },\n        examples: {\n          [exampleKey]: { value },\n        },\n      }))\n    : []\n\n  const headerParams = Object.entries(headers || {}).map(([key, value]) => ({\n    name: key,\n    in: 'header' as const,\n    schema: { type: inferSchemaType(value) },\n    examples: {\n      [exampleKey]: { value },\n    },\n  }))\n\n  return [...queryParams, ...headerParams]\n}\n\n/**\n * Creates a request body schema from parsed data.\n * Generates an object schema with properties inferred from the data structure.\n */\nconst createRequestBodySchema = (data: ParsedData): SchemaObject => {\n  const properties = Object.fromEntries(\n    Object.entries(data).map(([key, value]) => [key, { type: inferSchemaType(value) } as SchemaObject]),\n  )\n\n  return {\n    type: 'object',\n    properties,\n  }\n}\n\n/** Don't want to throw for invalid URLs */\nconst safePathname = (url: string) => {\n  try {\n    return new URL(url).pathname\n  } catch {\n    return '/'\n  }\n}\n\n/**\n * Converts a cURL command string into an OpenAPI operation object.\n *\n * This function parses a cURL command and extracts all relevant information\n * (path, method, headers, query parameters, request body) to create a complete\n * OpenAPI operation that can be used to populate a request in the API client.\n *\n * The exampleKey is used to namespace the example values in the operation object,\n * allowing multiple examples to coexist if needed.\n */\nexport const getOperationFromCurl = (curl: string, exampleKey = 'curl'): CurlOperationResult => {\n  const parsedCurl = parseCurlCommand(curl)\n\n  const { method = 'get', url, body = '', headers = {}, servers = [], queryParameters = [] } = parsedCurl\n\n  const path = safePathname(url)\n  const contentType = detectContentType(body, headers)\n  const requestBodyData = body ? parseRequestBodyData(body) : {}\n\n  const parameters = createParameters(queryParameters, headers, exampleKey)\n\n  const serverObjects: ServerObject[] = servers.map((server) => ({\n    url: server,\n  }))\n\n  return {\n    path,\n    method,\n    operation: {\n      parameters,\n      requestBody: {\n        content: {\n          [contentType]: {\n            schema: createRequestBodySchema(requestBodyData),\n            examples: {\n              [exampleKey]: { value: requestBodyData },\n            },\n          },\n        },\n        'x-scalar-selected-content-type': {\n          [exampleKey]: contentType,\n        },\n      },\n      servers: serverObjects.length ? serverObjects : undefined,\n    },\n  }\n}\n"],"mappings":";;;;;;;;AAiCA,IAAM,wBAAwB,SAA6B;AACzD,KAAI;AAEF,SAAO,KAAK,MAAM,KAAK;SACjB;EAEN,MAAM,SAAiC,EAAE;AAEzC,OAAK,MAAM,IAAI,CAAC,SAAS,SAAS;GAChC,MAAM,CAAC,KAAK,SAAS,KAAK,MAAM,IAAI;AACpC,OAAI,OAAO,MACT,QAAO,mBAAmB,IAAI,IAAI,mBAAmB,MAAM;IAE7D;AAEF,SAAO;;;;;;;;AASX,IAAM,qBAAqB,MAAc,YAA4C;AAEnF,KAAI,QAAQ,gBACV,QAAO,QAAQ;CAIjB,MAAM,cAAc,KAAK,MAAM;AAG/B,KAFe,YAAY,WAAW,IAAI,IAAI,YAAY,WAAW,IAAI,CAGvE,QAAO;AAMT,QAFsB,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,WAAW,IAAI,GAEjD,sCAAsC;;;;;;AAO/D,IAAM,mBAAmB,UAA2B;CAClD,MAAM,SAAS,OAAO;AAGtB,KAAI,WAAW,SACb,QAAO;AAET,KAAI,WAAW,SACb,QAAO;AAET,KAAI,WAAW,UACb,QAAO;AAET,KAAI,UAAU,KACZ,QAAO;AAET,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO;AAET,KAAI,WAAW,SACb,QAAO;AAIT,QAAO;;;;;;AAOT,IAAM,oBACJ,iBACA,SACA,eACsB;CACtB,MAAM,cAAc,MAAM,QAAQ,gBAAgB,GAC9C,gBAAgB,KAAK,EAAE,KAAK,aAAa;EACvC,MAAM;EACN,IAAI;EACJ,QAAQ,EAAE,MAAM,gBAAgB,MAAM,EAAE;EACxC,UAAU,GACP,aAAa,EAAE,OAAO,EACxB;EACF,EAAE,GACH,EAAE;CAEN,MAAM,eAAe,OAAO,QAAQ,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,YAAY;EACxE,MAAM;EACN,IAAI;EACJ,QAAQ,EAAE,MAAM,gBAAgB,MAAM,EAAE;EACxC,UAAU,GACP,aAAa,EAAE,OAAO,EACxB;EACF,EAAE;AAEH,QAAO,CAAC,GAAG,aAAa,GAAG,aAAa;;;;;;AAO1C,IAAM,2BAA2B,SAAmC;AAKlE,QAAO;EACL,MAAM;EACN,YANiB,OAAO,YACxB,OAAO,QAAQ,KAAK,CAAC,KAAK,CAAC,KAAK,WAAW,CAAC,KAAK,EAAE,MAAM,gBAAgB,MAAM,EAAE,CAAiB,CAAC,CACpG;EAKA;;;AAIH,IAAM,gBAAgB,QAAgB;AACpC,KAAI;AACF,SAAO,IAAI,IAAI,IAAI,CAAC;SACd;AACN,SAAO;;;;;;;;;;;;;AAcX,IAAa,wBAAwB,MAAc,aAAa,WAAgC;CAG9F,MAAM,EAAE,SAAS,OAAO,KAAK,OAAO,IAAI,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,kBAAkB,EAAE,KAFrE,iBAAiB,KAAK;CAIzC,MAAM,OAAO,aAAa,IAAI;CAC9B,MAAM,cAAc,kBAAkB,MAAM,QAAQ;CACpD,MAAM,kBAAkB,OAAO,qBAAqB,KAAK,GAAG,EAAE;CAE9D,MAAM,aAAa,iBAAiB,iBAAiB,SAAS,WAAW;CAEzE,MAAM,gBAAgC,QAAQ,KAAK,YAAY,EAC7D,KAAK,QACN,EAAE;AAEH,QAAO;EACL;EACA;EACA,WAAW;GACT;GACA,aAAa;IACX,SAAS,GACN,cAAc;KACb,QAAQ,wBAAwB,gBAAgB;KAChD,UAAU,GACP,aAAa,EAAE,OAAO,iBAAiB,EACzC;KACF,EACF;IACD,kCAAkC,GAC/B,aAAa,aACf;IACF;GACD,SAAS,cAAc,SAAS,gBAAgB,KAAA;GACjD;EACF"}

package/dist/v2/features/command-palette/helpers/get-postman-document-details.d.ts

@@ -9,6 +9,10 @@ type PostmanDocumentDetails = {
     title: string;
     /** The version of the Postman collection. */
     version: string;
+    /** Postman collection schema segment from `info.schema` (e.g. `v2.1.0`), when present. */
+    schemaLabel?: string;
+    /** The collection items. */
+    collection: unknown[];
 };
 /**
  * Extracts document details from a Postman collection JSON string.

package/dist/v2/features/command-palette/helpers/get-postman-document-details.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-postman-document-details.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-postman-document-details.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,KAAK,sBAAsB,GAAG;IAC5B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,SAAS,MAAM,KAAG,sBAAsB,GAAG,IAgBpF,CAAA"}
+{"version":3,"file":"get-postman-document-details.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-postman-document-details.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,KAAK,sBAAsB,GAAG;IAC5B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAA;IACf,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4BAA4B;IAC5B,UAAU,EAAE,OAAO,EAAE,CAAA;CACtB,CAAA;AAUD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,SAAS,MAAM,KAAG,sBAAsB,GAAG,IAsBpF,CAAA"}

package/dist/v2/features/command-palette/helpers/get-postman-document-details.js

@@ -0,0 +1,36 @@
+import { isPostmanCollection } from "./is-postman-collection.js";
+//#region src/v2/features/command-palette/helpers/get-postman-document-details.ts
+var extractSchemaLabel = (schema) => {
+	if (typeof schema !== "string") return;
+	return schema.match(/\/collection\/(v[\d.]+)\//i)?.[1];
+};
+/**
+* Extracts document details from a Postman collection JSON string.
+*
+* We parse and validate in a single pass to avoid the performance cost
+* of parsing the JSON twice.
+*
+* @param content - The JSON string representing the Postman collection
+* @returns The collection details if valid, null otherwise
+*/
+var getPostmanDocumentDetails = (content) => {
+	if (!isPostmanCollection(content)) return null;
+	try {
+		const parsed = JSON.parse(content);
+		const schemaLabel = extractSchemaLabel(parsed.info?.schema);
+		const collectionItems = Array.isArray(parsed.item) ? parsed.item : [];
+		return {
+			type: "json",
+			title: parsed.info?.name || "Postman Collection",
+			version: parsed.info?.version || "1.0",
+			schemaLabel: schemaLabel ?? void 0,
+			collection: collectionItems
+		};
+	} catch {
+		return null;
+	}
+};
+//#endregion
+export { getPostmanDocumentDetails };
+
+//# sourceMappingURL=get-postman-document-details.js.map

package/dist/v2/features/command-palette/helpers/get-postman-document-details.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-postman-document-details.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/get-postman-document-details.ts"],"sourcesContent":["import { isPostmanCollection } from '@/v2/features/command-palette/helpers/is-postman-collection'\n\n/**\n * Represents the extracted details from a Postman collection.\n * Used to display collection metadata in the command palette import UI.\n */\ntype PostmanDocumentDetails = {\n  /** The document format type. */\n  type: string\n  /** The name of the Postman collection. */\n  title: string\n  /** The version of the Postman collection. */\n  version: string\n  /** Postman collection schema segment from `info.schema` (e.g. `v2.1.0`), when present. */\n  schemaLabel?: string\n  /** The collection items. */\n  collection: unknown[]\n}\n\nconst extractSchemaLabel = (schema: unknown): string | undefined => {\n  if (typeof schema !== 'string') {\n    return undefined\n  }\n  const match = schema.match(/\\/collection\\/(v[\\d.]+)\\//i)\n  return match?.[1]\n}\n\n/**\n * Extracts document details from a Postman collection JSON string.\n *\n * We parse and validate in a single pass to avoid the performance cost\n * of parsing the JSON twice.\n *\n * @param content - The JSON string representing the Postman collection\n * @returns The collection details if valid, null otherwise\n */\nexport const getPostmanDocumentDetails = (content: string): PostmanDocumentDetails | null => {\n  if (!isPostmanCollection(content)) {\n    return null\n  }\n\n  try {\n    const parsed = JSON.parse(content)\n\n    const schemaLabel = extractSchemaLabel(parsed.info?.schema)\n\n    const collectionItems = Array.isArray(parsed.item) ? parsed.item : []\n\n    return {\n      type: 'json',\n      title: parsed.info?.name || 'Postman Collection',\n      version: parsed.info?.version || '1.0',\n      schemaLabel: schemaLabel ?? undefined,\n      collection: collectionItems,\n    }\n  } catch {\n    return null\n  }\n}\n"],"mappings":";;AAmBA,IAAM,sBAAsB,WAAwC;AAClE,KAAI,OAAO,WAAW,SACpB;AAGF,QADc,OAAO,MAAM,6BAA6B,GACzC;;;;;;;;;;;AAYjB,IAAa,6BAA6B,YAAmD;AAC3F,KAAI,CAAC,oBAAoB,QAAQ,CAC/B,QAAO;AAGT,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,QAAQ;EAElC,MAAM,cAAc,mBAAmB,OAAO,MAAM,OAAO;EAE3D,MAAM,kBAAkB,MAAM,QAAQ,OAAO,KAAK,GAAG,OAAO,OAAO,EAAE;AAErE,SAAO;GACL,MAAM;GACN,OAAO,OAAO,MAAM,QAAQ;GAC5B,SAAS,OAAO,MAAM,WAAW;GACjC,aAAa,eAAe,KAAA;GAC5B,YAAY;GACb;SACK;AACN,SAAO"}

package/dist/v2/features/command-palette/helpers/import-document-to-workspace.js

@@ -0,0 +1,70 @@
+import { generateUniqueSlug } from "./generate-unique-slug.js";
+//#region src/v2/features/command-palette/helpers/import-document-to-workspace.ts
+/**
+* Imports a single document from a workspace state into the current workspace.
+*
+* This function handles the complete import process including slug generation,
+* document loading, and sidebar updates. It ensures the imported document does not
+* conflict with existing documents by generating a unique slug.
+*
+* The meta from the importing workspace is intentionally excluded to preserve
+* the current workspace settings and avoid unintended configuration changes.
+*
+* @param workspaceStore - The active workspace store where the document will be imported
+* @param workspaceState - The in-memory workspace containing the document to import
+* @param name - The original slug/name of the document in the source workspace state
+*
+* @returns Promise that resolves to the slug of the imported document
+*/
+var importDocumentToWorkspace = async ({ workspaceStore, workspaceState, name }) => {
+	if (!workspaceStore) return {
+		ok: false,
+		error: "Workspace store is not available"
+	};
+	const importingDocument = workspaceState.documents[name];
+	if (!importingDocument) return {
+		ok: false,
+		error: "Importing document not found in workspace state"
+	};
+	const currentDocuments = new Set(Object.keys(workspaceStore.workspace.documents));
+	/**
+	* Generate a unique slug to avoid naming conflicts with existing documents.
+	* The slug is based on the document title but modified if necessary to ensure uniqueness.
+	*/
+	const slug = await generateUniqueSlug(importingDocument.info.title || "default", currentDocuments);
+	if (!slug) return {
+		ok: false,
+		error: "Failed to generate a unique slug for the importing document"
+	};
+	/**
+	* Load the document along with all its associated data structures.
+	* We intentionally pass an empty meta object to preserve the current workspace settings.
+	*/
+	workspaceStore.loadWorkspace({
+		meta: {},
+		documents: { [slug]: importingDocument },
+		intermediateDocuments: { [slug]: workspaceState.intermediateDocuments[name] ?? {} },
+		originalDocuments: { [slug]: workspaceState.originalDocuments[name] ?? {} },
+		overrides: { [slug]: workspaceState.overrides[name] ?? {} },
+		history: {},
+		auth: {}
+	});
+	/**
+	* Rebuild the sidebar to update all internal references from the old slug to the new one.
+	* This ensures the document appears correctly in the sidebar navigation.
+	*/
+	workspaceStore.buildSidebar(slug);
+	/**
+	* Persist the imported document and the changes made during sidebar rebuilding.
+	* Without this, the import would be lost on page refresh.
+	*/
+	await workspaceStore.saveDocument(slug);
+	return {
+		ok: true,
+		slug
+	};
+};
+//#endregion
+export { importDocumentToWorkspace };
+
+//# sourceMappingURL=import-document-to-workspace.js.map

package/dist/v2/features/command-palette/helpers/import-document-to-workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-document-to-workspace.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/import-document-to-workspace.ts"],"sourcesContent":["import type { WorkspaceStore } from '@scalar/workspace-store/client'\nimport type { InMemoryWorkspace } from '@scalar/workspace-store/schemas/inmemory-workspace'\n\nimport { generateUniqueSlug } from '@/v2/features/command-palette/helpers/generate-unique-slug'\n\n/**\n * Imports a single document from a workspace state into the current workspace.\n *\n * This function handles the complete import process including slug generation,\n * document loading, and sidebar updates. It ensures the imported document does not\n * conflict with existing documents by generating a unique slug.\n *\n * The meta from the importing workspace is intentionally excluded to preserve\n * the current workspace settings and avoid unintended configuration changes.\n *\n * @param workspaceStore - The active workspace store where the document will be imported\n * @param workspaceState - The in-memory workspace containing the document to import\n * @param name - The original slug/name of the document in the source workspace state\n *\n * @returns Promise that resolves to the slug of the imported document\n */\nexport const importDocumentToWorkspace = async ({\n  workspaceStore,\n  workspaceState,\n  name,\n}: {\n  workspaceStore: WorkspaceStore | null\n  workspaceState: InMemoryWorkspace\n  name: string\n}): Promise<{ ok: true; slug: string } | { ok: false; error: string }> => {\n  if (!workspaceStore) {\n    return { ok: false, error: 'Workspace store is not available' }\n  }\n\n  const importingDocument = workspaceState.documents[name]\n  if (!importingDocument) {\n    return { ok: false, error: 'Importing document not found in workspace state' }\n  }\n\n  const currentDocuments = new Set(Object.keys(workspaceStore.workspace.documents))\n\n  /**\n   * Generate a unique slug to avoid naming conflicts with existing documents.\n   * The slug is based on the document title but modified if necessary to ensure uniqueness.\n   */\n  const slug = await generateUniqueSlug(importingDocument.info.title || 'default', currentDocuments)\n  if (!slug) {\n    return { ok: false, error: 'Failed to generate a unique slug for the importing document' }\n  }\n\n  /**\n   * Load the document along with all its associated data structures.\n   * We intentionally pass an empty meta object to preserve the current workspace settings.\n   */\n  workspaceStore.loadWorkspace({\n    meta: {},\n    documents: {\n      [slug]: importingDocument,\n    },\n    intermediateDocuments: {\n      [slug]: workspaceState.intermediateDocuments[name] ?? {},\n    },\n    originalDocuments: {\n      [slug]: workspaceState.originalDocuments[name] ?? {},\n    },\n    overrides: {\n      [slug]: workspaceState.overrides[name] ?? {},\n    },\n    history: {},\n    auth: {},\n  })\n\n  /**\n   * Rebuild the sidebar to update all internal references from the old slug to the new one.\n   * This ensures the document appears correctly in the sidebar navigation.\n   */\n  workspaceStore.buildSidebar(slug)\n\n  /**\n   * Persist the imported document and the changes made during sidebar rebuilding.\n   * Without this, the import would be lost on page refresh.\n   */\n  await workspaceStore.saveDocument(slug)\n\n  return { ok: true, slug }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAa,4BAA4B,OAAO,EAC9C,gBACA,gBACA,WAKwE;AACxE,KAAI,CAAC,eACH,QAAO;EAAE,IAAI;EAAO,OAAO;EAAoC;CAGjE,MAAM,oBAAoB,eAAe,UAAU;AACnD,KAAI,CAAC,kBACH,QAAO;EAAE,IAAI;EAAO,OAAO;EAAmD;CAGhF,MAAM,mBAAmB,IAAI,IAAI,OAAO,KAAK,eAAe,UAAU,UAAU,CAAC;;;;;CAMjF,MAAM,OAAO,MAAM,mBAAmB,kBAAkB,KAAK,SAAS,WAAW,iBAAiB;AAClG,KAAI,CAAC,KACH,QAAO;EAAE,IAAI;EAAO,OAAO;EAA+D;;;;;AAO5F,gBAAe,cAAc;EAC3B,MAAM,EAAE;EACR,WAAW,GACR,OAAO,mBACT;EACD,uBAAuB,GACpB,OAAO,eAAe,sBAAsB,SAAS,EAAE,EACzD;EACD,mBAAmB,GAChB,OAAO,eAAe,kBAAkB,SAAS,EAAE,EACrD;EACD,WAAW,GACR,OAAO,eAAe,UAAU,SAAS,EAAE,EAC7C;EACD,SAAS,EAAE;EACX,MAAM,EAAE;EACT,CAAC;;;;;AAMF,gBAAe,aAAa,KAAK;;;;;AAMjC,OAAM,eAAe,aAAa,KAAK;AAEvC,QAAO;EAAE,IAAI;EAAM;EAAM"}

package/dist/v2/features/command-palette/helpers/is-postman-collection.js

@@ -0,0 +1,24 @@
+//#region src/v2/features/command-palette/helpers/is-postman-collection.ts
+/**
+* Checks if the given string content is a Postman collection.
+*
+* Validates by checking for the `_postman_id` in the info object
+* and ensuring the schema URL's host matches 'schema.getpostman.com'.
+*
+* @param content - The JSON string which may be a Postman collection
+* @returns True if the content is a valid Postman collection
+*/
+var isPostmanCollection = (content) => {
+	try {
+		const parsed = JSON.parse(content);
+		const hasPostmanId = parsed.info?._postman_id !== void 0;
+		const hasValidSchema = parsed.info?.schema && new URL(parsed.info.schema).host === "schema.getpostman.com";
+		return hasPostmanId && hasValidSchema;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+export { isPostmanCollection };
+
+//# sourceMappingURL=is-postman-collection.js.map

package/dist/v2/features/command-palette/helpers/is-postman-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-postman-collection.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/is-postman-collection.ts"],"sourcesContent":["/**\n * Checks if the given string content is a Postman collection.\n *\n * Validates by checking for the `_postman_id` in the info object\n * and ensuring the schema URL's host matches 'schema.getpostman.com'.\n *\n * @param content - The JSON string which may be a Postman collection\n * @returns True if the content is a valid Postman collection\n */\nexport const isPostmanCollection = (content: string): boolean => {\n  try {\n    const parsed = JSON.parse(content)\n\n    const hasPostmanId = parsed.info?._postman_id !== undefined\n    const hasValidSchema = parsed.info?.schema && new URL(parsed.info.schema).host === 'schema.getpostman.com'\n\n    return hasPostmanId && hasValidSchema\n  } catch {\n    return false\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,IAAa,uBAAuB,YAA6B;AAC/D,KAAI;EACF,MAAM,SAAS,KAAK,MAAM,QAAQ;EAElC,MAAM,eAAe,OAAO,MAAM,gBAAgB,KAAA;EAClD,MAAM,iBAAiB,OAAO,MAAM,UAAU,IAAI,IAAI,OAAO,KAAK,OAAO,CAAC,SAAS;AAEnF,SAAO,gBAAgB;SACjB;AACN,SAAO"}

package/dist/v2/features/command-palette/helpers/load-document-from-source.js

@@ -0,0 +1,71 @@
+import { isPostmanCollection } from "./is-postman-collection.js";
+import { getOpenApiFromPostman } from "./get-openapi-from-postman.js";
+import { isObject } from "@scalar/helpers/object/is-object";
+import { parseJson, parseYaml } from "@scalar/json-magic/bundle/plugins/browser";
+//#region src/v2/features/command-palette/helpers/load-document-from-source.ts
+/**
+* Loader plugin to detect and convert Postman collections into OpenAPI documents
+*/
+var readPostmanCollection = () => {
+	return {
+		type: "loader",
+		validate: isPostmanCollection,
+		exec: (source) => {
+			try {
+				const document = getOpenApiFromPostman(source);
+				if (document) return Promise.resolve({
+					ok: true,
+					data: document,
+					raw: source
+				});
+				return Promise.resolve({ ok: false });
+			} catch {
+				return Promise.resolve({ ok: false });
+			}
+		}
+	};
+};
+/**
+* Attempts to add a document to the workspace from a given source, which may be a URL or raw content.
+*
+* - If the source is a URL, adds the document by its URL and includes a watch mode flag as metadata.
+* - If the source is a Postman collection, transforms it to OpenAPI and adds it as a document.
+* - For other raw sources (such as pasted JSON or YAML), attempts to normalize and add them as a document.
+*
+* @param workspaceStore The workspace store where the document will be added.
+* @param source The document source (URL, Postman Collection, JSON, or YAML string).
+* @param name The display name for the new document.
+* @param watchMode Whether to enable watch mode (applies only to URL sources).
+* @returns Promise resolving to true if the document was successfully added, or false if the operation failed.
+*/
+var loadDocumentFromSource = async (workspaceStore, importEventData, name, watchMode) => {
+	const { source, type } = importEventData;
+	if (!source) return false;
+	if (type === "url") return await workspaceStore.addDocument({
+		name,
+		url: source,
+		meta: { "x-scalar-watch-mode": watchMode }
+	});
+	if (type === "file") return await workspaceStore.addDocument({
+		name,
+		path: source
+	});
+	const loader = [
+		readPostmanCollection(),
+		parseJson(),
+		parseYaml()
+	].find((l) => l.validate(source));
+	if (!loader) return false;
+	const result = await loader.exec(source);
+	if (!result.ok) return false;
+	if (!isObject(result.data)) return false;
+	if (!await workspaceStore.addDocument({
+		name,
+		document: result.data
+	})) return false;
+	return true;
+};
+//#endregion
+export { loadDocumentFromSource };
+
+//# sourceMappingURL=load-document-from-source.js.map

package/dist/v2/features/command-palette/helpers/load-document-from-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-document-from-source.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/load-document-from-source.ts"],"sourcesContent":["import { isObject } from '@scalar/helpers/object/is-object'\nimport type { LoaderPlugin } from '@scalar/json-magic/bundle'\nimport { parseJson, parseYaml } from '@scalar/json-magic/bundle/plugins/browser'\nimport type { WorkspaceStore } from '@scalar/workspace-store/client'\n\nimport { getOpenApiFromPostman } from '@/v2/features/command-palette/helpers/get-openapi-from-postman'\nimport { isPostmanCollection } from '@/v2/features/command-palette/helpers/is-postman-collection'\n\nexport type ImportEventData = {\n  source: string\n  type: 'url' | 'file' | 'raw'\n}\n\n/**\n * Loader plugin to detect and convert Postman collections into OpenAPI documents\n */\nconst readPostmanCollection = (): LoaderPlugin => {\n  return {\n    type: 'loader',\n    validate: isPostmanCollection,\n    exec: (source: string) => {\n      try {\n        const document = getOpenApiFromPostman(source)\n\n        if (document) {\n          return Promise.resolve({\n            ok: true,\n            data: document,\n            raw: source,\n          })\n        }\n\n        return Promise.resolve({\n          ok: false,\n        })\n      } catch {\n        return Promise.resolve({\n          ok: false,\n        })\n      }\n    },\n  }\n}\n\n/**\n * Attempts to add a document to the workspace from a given source, which may be a URL or raw content.\n *\n * - If the source is a URL, adds the document by its URL and includes a watch mode flag as metadata.\n * - If the source is a Postman collection, transforms it to OpenAPI and adds it as a document.\n * - For other raw sources (such as pasted JSON or YAML), attempts to normalize and add them as a document.\n *\n * @param workspaceStore The workspace store where the document will be added.\n * @param source The document source (URL, Postman Collection, JSON, or YAML string).\n * @param name The display name for the new document.\n * @param watchMode Whether to enable watch mode (applies only to URL sources).\n * @returns Promise resolving to true if the document was successfully added, or false if the operation failed.\n */\nexport const loadDocumentFromSource = async (\n  workspaceStore: WorkspaceStore,\n  importEventData: ImportEventData,\n  name: string,\n  watchMode: boolean,\n): Promise<boolean> => {\n  const { source, type } = importEventData\n  if (!source) {\n    // No source provided, do nothing.\n    return false\n  }\n\n  // If the source is a URL, add it directly with watch mode metadata.\n  if (type === 'url') {\n    return await workspaceStore.addDocument({\n      name,\n      url: source,\n      meta: {\n        'x-scalar-watch-mode': watchMode,\n      },\n    })\n  }\n\n  if (type === 'file') {\n    return await workspaceStore.addDocument({\n      name,\n      path: source,\n    })\n  }\n\n  const loaders = [readPostmanCollection(), parseJson(), parseYaml()]\n  const loader = loaders.find((l) => l.validate(source))\n\n  // If no loader is found, return false\n  if (!loader) {\n    return false\n  }\n\n  // Execute the loader\n  const result = await loader.exec(source)\n  // If the loader failed, return false\n  if (!result.ok) {\n    return false\n  }\n\n  if (!isObject(result.data)) {\n    return false\n  }\n\n  const addDocumentResult = await workspaceStore.addDocument({\n    name,\n    document: result.data,\n  })\n\n  if (!addDocumentResult) {\n    return false\n  }\n\n  return true\n}\n"],"mappings":";;;;;;;;AAgBA,IAAM,8BAA4C;AAChD,QAAO;EACL,MAAM;EACN,UAAU;EACV,OAAO,WAAmB;AACxB,OAAI;IACF,MAAM,WAAW,sBAAsB,OAAO;AAE9C,QAAI,SACF,QAAO,QAAQ,QAAQ;KACrB,IAAI;KACJ,MAAM;KACN,KAAK;KACN,CAAC;AAGJ,WAAO,QAAQ,QAAQ,EACrB,IAAI,OACL,CAAC;WACI;AACN,WAAO,QAAQ,QAAQ,EACrB,IAAI,OACL,CAAC;;;EAGP;;;;;;;;;;;;;;;AAgBH,IAAa,yBAAyB,OACpC,gBACA,iBACA,MACA,cACqB;CACrB,MAAM,EAAE,QAAQ,SAAS;AACzB,KAAI,CAAC,OAEH,QAAO;AAIT,KAAI,SAAS,MACX,QAAO,MAAM,eAAe,YAAY;EACtC;EACA,KAAK;EACL,MAAM,EACJ,uBAAuB,WACxB;EACF,CAAC;AAGJ,KAAI,SAAS,OACX,QAAO,MAAM,eAAe,YAAY;EACtC;EACA,MAAM;EACP,CAAC;CAIJ,MAAM,SADU;EAAC,uBAAuB;EAAE,WAAW;EAAE,WAAW;EAAC,CAC5C,MAAM,MAAM,EAAE,SAAS,OAAO,CAAC;AAGtD,KAAI,CAAC,OACH,QAAO;CAIT,MAAM,SAAS,MAAM,OAAO,KAAK,OAAO;AAExC,KAAI,CAAC,OAAO,GACV,QAAO;AAGT,KAAI,CAAC,SAAS,OAAO,KAAK,CACxB,QAAO;AAQT,KAAI,CALsB,MAAM,eAAe,YAAY;EACzD;EACA,UAAU,OAAO;EAClB,CAAC,CAGA,QAAO;AAGT,QAAO"}

package/dist/v2/features/command-palette/helpers/postman-request-collisions.d.ts

@@ -0,0 +1,11 @@
+import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Among the selected Postman request path keys, returns keys whose requests map to the same
+ * OpenAPI path + HTTP method as another selected request or an existing operation in the base document.
+ *
+ * @param itemRoot - Postman collection `item` array
+ * @param selectedPathKeys - Selected Postman request path keys (JSON index paths)
+ * @param baseDocument - Optional existing OpenAPI document to check for collisions
+ */
+export declare const getCollidingPostmanRequestPathKeys: (itemRoot: unknown, selectedPathKeys: readonly string[], baseDocument?: OpenApiDocument) => string[];
+//# sourceMappingURL=postman-request-collisions.d.ts.map

package/dist/v2/features/command-palette/helpers/postman-request-collisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postman-request-collisions.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/postman-request-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8DAA8D,CAAA;AAKnG;;;;;;;GAOG;AACH,eAAO,MAAM,kCAAkC,GAC7C,UAAU,OAAO,EACjB,kBAAkB,SAAS,MAAM,EAAE,EACnC,eAAe,eAAe,KAC7B,MAAM,EAgCR,CAAA"}

package/dist/v2/features/command-palette/helpers/postman-request-collisions.js

@@ -0,0 +1,35 @@
+import { getPostmanItemAtIndexPath } from "./postman-request-tree.js";
+import { getOpenApiMergeKeys, getPostmanMergeKeys } from "./get-merge-key.js";
+//#region src/v2/features/command-palette/helpers/postman-request-collisions.ts
+/**
+* Among the selected Postman request path keys, returns keys whose requests map to the same
+* OpenAPI path + HTTP method as another selected request or an existing operation in the base document.
+*
+* @param itemRoot - Postman collection `item` array
+* @param selectedPathKeys - Selected Postman request path keys (JSON index paths)
+* @param baseDocument - Optional existing OpenAPI document to check for collisions
+*/
+var getCollidingPostmanRequestPathKeys = (itemRoot, selectedPathKeys, baseDocument) => {
+	const byMergeKey = /* @__PURE__ */ new Map();
+	const baseMergeKeys = baseDocument ? getOpenApiMergeKeys(baseDocument) : /* @__PURE__ */ new Set();
+	for (const key of selectedPathKeys) {
+		let path;
+		try {
+			path = JSON.parse(key);
+		} catch {
+			continue;
+		}
+		const mergeKey = getPostmanMergeKeys(getPostmanItemAtIndexPath(itemRoot, path));
+		if (mergeKey === void 0) continue;
+		const list = byMergeKey.get(mergeKey) ?? [];
+		list.push(key);
+		byMergeKey.set(mergeKey, list);
+	}
+	const colliding = [];
+	for (const [mergeKey, keys] of byMergeKey.entries()) if (keys.length > 1 || baseMergeKeys.has(mergeKey)) colliding.push(...keys);
+	return colliding;
+};
+//#endregion
+export { getCollidingPostmanRequestPathKeys };
+
+//# sourceMappingURL=postman-request-collisions.js.map

package/dist/v2/features/command-palette/helpers/postman-request-collisions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postman-request-collisions.js","names":[],"sources":["../../../../../src/v2/features/command-palette/helpers/postman-request-collisions.ts"],"sourcesContent":["import type { OpenApiDocument } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document'\n\nimport { getOpenApiMergeKeys, getPostmanMergeKeys } from '@/v2/features/command-palette/helpers/get-merge-key'\nimport { getPostmanItemAtIndexPath } from '@/v2/features/command-palette/helpers/postman-request-tree'\n\n/**\n * Among the selected Postman request path keys, returns keys whose requests map to the same\n * OpenAPI path + HTTP method as another selected request or an existing operation in the base document.\n *\n * @param itemRoot - Postman collection `item` array\n * @param selectedPathKeys - Selected Postman request path keys (JSON index paths)\n * @param baseDocument - Optional existing OpenAPI document to check for collisions\n */\nexport const getCollidingPostmanRequestPathKeys = (\n  itemRoot: unknown,\n  selectedPathKeys: readonly string[],\n  baseDocument?: OpenApiDocument,\n): string[] => {\n  const byMergeKey = new Map<string, string[]>()\n\n  // Collect merge keys from the base document if provided\n  const baseMergeKeys = baseDocument ? getOpenApiMergeKeys(baseDocument) : new Set<string>()\n\n  for (const key of selectedPathKeys) {\n    let path: number[]\n    try {\n      path = JSON.parse(key) as number[]\n    } catch {\n      continue\n    }\n    const leaf = getPostmanItemAtIndexPath(itemRoot, path)\n    const mergeKey = getPostmanMergeKeys(leaf)\n    if (mergeKey === undefined) {\n      continue\n    }\n\n    const list = byMergeKey.get(mergeKey) ?? []\n    list.push(key)\n    byMergeKey.set(mergeKey, list)\n  }\n\n  const colliding: string[] = []\n  for (const [mergeKey, keys] of byMergeKey.entries()) {\n    // Collision if: multiple requests share the same merge key, OR any request collides with base\n    if (keys.length > 1 || baseMergeKeys.has(mergeKey)) {\n      colliding.push(...keys)\n    }\n  }\n  return colliding\n}\n"],"mappings":";;;;;;;;;;;AAaA,IAAa,sCACX,UACA,kBACA,iBACa;CACb,MAAM,6BAAa,IAAI,KAAuB;CAG9C,MAAM,gBAAgB,eAAe,oBAAoB,aAAa,mBAAG,IAAI,KAAa;AAE1F,MAAK,MAAM,OAAO,kBAAkB;EAClC,IAAI;AACJ,MAAI;AACF,UAAO,KAAK,MAAM,IAAI;UAChB;AACN;;EAGF,MAAM,WAAW,oBADJ,0BAA0B,UAAU,KAAK,CACZ;AAC1C,MAAI,aAAa,KAAA,EACf;EAGF,MAAM,OAAO,WAAW,IAAI,SAAS,IAAI,EAAE;AAC3C,OAAK,KAAK,IAAI;AACd,aAAW,IAAI,UAAU,KAAK;;CAGhC,MAAM,YAAsB,EAAE;AAC9B,MAAK,MAAM,CAAC,UAAU,SAAS,WAAW,SAAS,CAEjD,KAAI,KAAK,SAAS,KAAK,cAAc,IAAI,SAAS,CAChD,WAAU,KAAK,GAAG,KAAK;AAG3B,QAAO"}

package/dist/v2/features/command-palette/helpers/postman-request-tree.d.ts

@@ -0,0 +1,41 @@
+export type PostmanTreeNode = {
+    path: readonly number[];
+    name: string;
+    isFolder: boolean;
+    method?: string;
+    children?: PostmanTreeNode[];
+};
+export declare const pathKey: (path: readonly number[]) => string;
+/**
+ * Inverse of {@link pathKey}: parses stable request index path JSON from the UI.
+ * Returns undefined for malformed input.
+ */
+export declare const parsePostmanPathKey: (key: string) => readonly number[] | undefined;
+/** Maps UI path keys to `ConvertOptions.requestIndexPaths`; invalid keys are skipped. */
+export declare const pathKeysToRequestIndexPaths: (keys: readonly string[]) => number[][];
+/**
+ * Resolves the Postman JSON node at `path` (indices into root `item`, then each folder’s `item`).
+ * Matches {@link buildPostmanRequestTree} paths and postman-to-openapi `getNodeAtPath`.
+ */
+export declare const getPostmanItemAtIndexPath: (itemRoot: unknown, path: readonly number[]) => unknown;
+export declare const extractRequestMethod: (request: unknown) => string;
+/**
+ * Builds a shallow tree of folders and requests from a Postman `item` array.
+ * Paths are indices from the collection root through nested `item` arrays.
+ */
+export declare const buildPostmanRequestTree: (items: unknown) => PostmanTreeNode[];
+/** Counts Postman request leaves in an `item` array (same rules as {@link buildPostmanRequestTree}). */
+export declare const countPostmanRequestLeaves: (items: unknown) => number;
+/** Path keys for every request leaf in the tree (depth-first). */
+export declare const collectAllRequestPathKeys: (nodes: PostmanTreeNode[]) => string[];
+export declare const collectRequestPathKeysUnderFolder: (node: PostmanTreeNode) => string[];
+/** Returns a new selection list after toggling one request path key. */
+export declare const applyPostmanRequestSelectionChange: (selectedKeys: readonly string[], key: string, selected: boolean) => string[];
+/** Returns a new selection list after selecting or clearing every request under a folder. */
+export declare const applyPostmanFolderSelectionChange: (selectedKeys: readonly string[], node: PostmanTreeNode, selected: boolean) => string[];
+/** Number of request leaves under this node (0 for empty folders). */
+export declare const countRequestLeaves: (node: PostmanTreeNode) => number;
+export declare const folderFullySelected: (node: PostmanTreeNode, selected: ReadonlySet<string>) => boolean;
+/** True when at least one descendant request is selected but not all. */
+export declare const folderHasPartialSelection: (node: PostmanTreeNode, selected: ReadonlySet<string>) => boolean;
+//# sourceMappingURL=postman-request-tree.d.ts.map

package/dist/v2/features/command-palette/helpers/postman-request-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postman-request-tree.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/postman-request-tree.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAA;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;CAC7B,CAAA;AAQD,eAAO,MAAM,OAAO,GAAI,MAAM,SAAS,MAAM,EAAE,KAAG,MAAmC,CAAA;AAErF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,SAAS,MAAM,EAAE,GAAG,SAerE,CAAA;AAED,yFAAyF;AACzF,eAAO,MAAM,2BAA2B,GAAI,MAAM,SAAS,MAAM,EAAE,KAAG,MAAM,EAAE,EAS7E,CAAA;AASD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GAAI,UAAU,OAAO,EAAE,MAAM,SAAS,MAAM,EAAE,KAAG,OAuBtF,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,SAAS,OAAO,KAAG,MAWvD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,eAAe,EAqCvE,CAAA;AAED,wGAAwG;AACxG,eAAO,MAAM,yBAAyB,GAAI,OAAO,OAAO,KAAG,MAe1D,CAAA;AAED,kEAAkE;AAClE,eAAO,MAAM,yBAAyB,GAAI,OAAO,eAAe,EAAE,KAAG,MAAM,EAU1E,CAAA;AAED,eAAO,MAAM,iCAAiC,GAAI,MAAM,eAAe,KAAG,MAAM,EAK/E,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,kCAAkC,GAC7C,cAAc,SAAS,MAAM,EAAE,EAC/B,KAAK,MAAM,EACX,UAAU,OAAO,KAChB,MAAM,EAQR,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,iCAAiC,GAC5C,cAAc,SAAS,MAAM,EAAE,EAC/B,MAAM,eAAe,EACrB,UAAU,OAAO,KAChB,MAAM,EAWR,CAAA;AAED,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,GAAI,MAAM,eAAe,KAAG,MAK1D,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,MAAM,eAAe,EAAE,UAAU,WAAW,CAAC,MAAM,CAAC,KAAG,OAG1F,CAAA;AAED,yEAAyE;AACzE,eAAO,MAAM,yBAAyB,GAAI,MAAM,eAAe,EAAE,UAAU,WAAW,CAAC,MAAM,CAAC,KAAG,OAYhG,CAAA"}