@scalar/api-client 2.12.0 → 2.13.0

package/dist/v2/features/command-palette/components/TheCommandPalette.vue2.js

@@ -0,0 +1,172 @@
+import { defineComponent as M, ref as N, computed as E, watch as $, createBlock as p, openBlock as l, unref as s, withCtx as f, createElementVNode as m, createVNode as u, createElementBlock as r, createTextVNode as I, createCommentVNode as v, withKeys as C, withModifiers as h, Fragment as S, renderList as O, withDirectives as K, toDisplayString as _, vShow as R, normalizeClass as V, resolveDynamicComponent as X, mergeProps as A, nextTick as Q } from "vue";
+import { Dialog as F, DialogPanel as q, DialogTitle as H } from "@headlessui/vue";
+import { ScalarIcon as y } from "@scalar/components";
+import { useRouter as W } from "vue-router";
+import j from "./CommandPaletteDocument.vue.js";
+import G from "./CommandPaletteExample.vue.js";
+import J from "./CommandPaletteImport.vue.js";
+import U from "./CommandPaletteImportCurl.vue.js";
+import Y from "./CommandPaletteRequest.vue.js";
+import Z from "./CommandPaletteTag.vue.js";
+const ee = {
+  key: 0,
+  class: "custom-scroll max-h-[50dvh] min-h-0 flex-1 rounded-lg p-1.5"
+}, te = { class: "bg-b-2 focus-within:bg-b-1 sticky top-0 flex items-center rounded-md border border-transparent pl-2 shadow-[0_-8px_0_8px_var(--scalar-background-1),0_0_8px_8px_var(--scalar-background-1)] focus-within:border-(--scalar-background-3)" }, oe = { for: "commandmenu" }, ae = ["value", "onKeydown"], ne = ["id", "onClick"], le = {
+  key: 0,
+  class: "text-c-3 p-2 pt-3 text-center text-sm"
+}, re = {
+  key: 1,
+  class: "flex-1 p-1.5"
+}, se = {}, ke = /* @__PURE__ */ M({
+  ...se,
+  __name: "TheCommandPalette",
+  props: {
+    paletteState: {},
+    workspaceStore: {},
+    eventBus: {}
+  },
+  setup(a) {
+    const D = {
+      "import-from-openapi-swagger-postman-curl": J,
+      "create-document": j,
+      "create-request": Y,
+      "add-tag": Z,
+      "add-example": G,
+      "import-curl-command": U
+    }, T = W(), i = N(-1), k = N(null), c = E(
+      () => a.paletteState.filteredCommands.value.flatMap((e) => e.commands)
+    ), d = E(
+      () => c.value[i.value]
+    );
+    $(
+      () => a.paletteState.filterQuery.value,
+      (e) => {
+        i.value = e && c.value.length > 0 ? 0 : -1;
+      }
+    );
+    const B = (e) => {
+      a.paletteState.setFilterQuery(e), e.trim().toLowerCase().startsWith("curl") && a.paletteState.open("import-curl-command", { curl: e });
+    }, b = (e, t) => {
+      if (!a.paletteState.isOpen.value)
+        return;
+      t.preventDefault();
+      const o = e === "up" ? -1 : 1, n = c.value.length;
+      i.value = (i.value + o + n) % n;
+    }, P = (e) => {
+      !d.value || a.paletteState.activeCommand.value || (e.preventDefault(), e.stopPropagation(), x(d.value));
+    }, x = (e) => {
+      if (e.type === "route") {
+        T.push(e.to), w();
+        return;
+      }
+      e.type === "folder" && a.paletteState.open(e.id, void 0);
+    }, g = () => {
+      a.paletteState.reset(), Q(() => k.value?.focus());
+    }, z = () => {
+      a.paletteState.close();
+    }, L = (...e) => {
+      a.paletteState.open(...e);
+    }, w = () => {
+      a.paletteState.close(), i.value = -1;
+    };
+    return (e, t) => (l(), p(s(F), {
+      open: e.paletteState.isOpen.value,
+      onClose: w
+    }, {
+      default: f(() => [
+        t[4] || (t[4] = m("div", { class: "commandmenu-overlay z-overlay" }, null, -1)),
+        u(s(q), { class: "commandmenu z-overlay flex flex-col" }, {
+          default: f(() => [
+            u(s(H), { class: "sr-only" }, {
+              default: f(() => [...t[3] || (t[3] = [
+                I("API Client Command Menu", -1)
+              ])]),
+              _: 1
+            }),
+            e.paletteState.activeCommand.value ? (l(), r("div", re, [
+              m("button", {
+                class: "hover:bg-b-3 text-c-3 active:text-c-1 absolute z-1 mt-[0.5px] rounded p-1.5",
+                type: "button",
+                onClick: g
+              }, [
+                u(s(y), {
+                  icon: "ChevronLeft",
+                  size: "md",
+                  thickness: "1.5"
+                })
+              ]),
+              e.paletteState.activeCommand.value ? (l(), p(X(D[e.paletteState.activeCommand.value]), A({ key: 0 }, {
+                workspaceStore: e.workspaceStore,
+                eventBus: e.eventBus,
+                ...e.paletteState.activeCommandProps.value
+              }, {
+                onBack: g,
+                onClose: z,
+                onOpenCommand: L
+              }), null, 16)) : v("", !0)
+            ])) : (l(), r("div", ee, [
+              m("div", te, [
+                m("label", oe, [
+                  u(s(y), {
+                    class: "text-c-2 mr-2.5",
+                    icon: "Search",
+                    size: "md",
+                    thickness: "1.5"
+                  })
+                ]),
+                m("input", {
+                  id: "commandmenu",
+                  ref_key: "commandInputRef",
+                  ref: k,
+                  autocomplete: "off",
+                  autofocus: "",
+                  class: "w-full rounded border-none bg-none py-1.5 text-sm focus:outline-none",
+                  placeholder: "Search commands...",
+                  type: "text",
+                  value: e.paletteState.filterQuery.value,
+                  onInput: t[0] || (t[0] = (o) => B(o.target.value)),
+                  onKeydown: [
+                    t[1] || (t[1] = C(h((o) => b("down", o), ["stop"]), ["down"])),
+                    C(h(P, ["stop"]), ["enter"]),
+                    t[2] || (t[2] = C(h((o) => b("up", o), ["stop"]), ["up"]))
+                  ]
+                }, null, 40, ae)
+              ]),
+              (l(!0), r(S, null, O(e.paletteState.filteredCommands.value, (o) => (l(), r(S, {
+                key: o.label
+              }, [
+                K(m("div", { class: "text-c-3 mt-2 mb-1 px-2 text-xs font-medium" }, _(o.label), 513), [
+                  [R, o.commands.length > 0]
+                ]),
+                (l(!0), r(S, null, O(o.commands, (n) => (l(), r("button", {
+                  id: n.id,
+                  key: n.id,
+                  class: V(["commandmenu-item hover:bg-b-2 flex w-full cursor-pointer items-center rounded px-2 py-1.5 text-left text-sm", {
+                    "bg-b-2": n.id === d.value?.id
+                  }]),
+                  type: "button",
+                  onClick: (ie) => x(n)
+                }, [
+                  "icon" in n ? (l(), p(s(y), {
+                    key: 0,
+                    class: "text-c-2 mr-2.5",
+                    icon: n.icon,
+                    size: "md",
+                    thickness: "1.5"
+                  }, null, 8, ["icon"])) : v("", !0),
+                  I(" " + _(n.name), 1)
+                ], 10, ne))), 128))
+              ], 64))), 128)),
+              e.paletteState.filteredCommands.value.length ? v("", !0) : (l(), r("div", le, " No commands found "))
+            ]))
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["open"]));
+  }
+});
+export {
+  ke as default
+};

package/dist/v2/features/command-palette/components/WatchModeToggle.vue.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Watch Mode Toggle Component
+ *
+ * A toggle switch for enabling/disabling watch mode on URL imports.
+ * When enabled, the API client automatically updates when the OpenAPI URL
+ * content changes, ensuring the client remains up-to-date.
+ *
+ * Supports v-model for two-way binding and can be disabled when needed
+ * (e.g., when importing from files instead of URLs).
+ *
+ * @example
+ * <WatchModeToggle
+ *   v-model="watchMode"
+ *   :disabled="!isUrlImport"
+ * />
+ */
+declare const _default: import("vue").DefineComponent<{
+    /** Whether watch mode is currently enabled */
+    modelValue: boolean;
+    /** Whether the toggle is disabled (e.g., for non-URL imports) */
+    disabled?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    /** Whether watch mode is currently enabled */
+    modelValue: boolean;
+    /** Whether the toggle is disabled (e.g., for non-URL imports) */
+    disabled?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=WatchModeToggle.vue.d.ts.map

package/dist/v2/features/command-palette/components/WatchModeToggle.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchModeToggle.vue.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/components/WatchModeToggle.vue"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;GAeG;;IAGD,8CAA8C;gBAClC,OAAO;IACnB,iEAAiE;eACtD,OAAO;;;;IAHlB,8CAA8C;gBAClC,OAAO;IACnB,iEAAiE;eACtD,OAAO;;;;AALpB,wBA8GC"}

package/dist/v2/features/command-palette/components/WatchModeToggle.vue.js

@@ -0,0 +1,40 @@
+import { defineComponent as u, computed as c, createElementBlock as i, openBlock as p, normalizeClass as o, createElementVNode as f, createVNode as a, createTextVNode as g, unref as d } from "vue";
+import { ScalarIcon as V, ScalarToggle as x } from "@scalar/components";
+const b = {}, N = /* @__PURE__ */ u({
+  ...b,
+  __name: "WatchModeToggle",
+  props: {
+    modelValue: { type: Boolean },
+    disabled: { type: Boolean, default: !1 }
+  },
+  emits: ["update:modelValue"],
+  setup(s, { emit: n }) {
+    const m = n, l = c({
+      get: () => s.modelValue,
+      set: (e) => m("update:modelValue", e)
+    });
+    return (e, t) => (p(), i("label", {
+      class: o(["text-c-2 flex items-center gap-2 rounded p-3 py-1.5 text-sm select-none", e.disabled ? "cursor-default" : "cursor-pointer"]),
+      for: "watch-toggle"
+    }, [
+      f("span", {
+        class: o(["text-c-1 flex items-center gap-1 text-xs font-medium", { "text-c-3": !e.modelValue }])
+      }, [
+        a(d(V), {
+          icon: "Watch",
+          size: "sm"
+        }),
+        t[1] || (t[1] = g(" Watch Mode ", -1))
+      ], 2),
+      a(d(x), {
+        id: "watch-toggle",
+        modelValue: l.value,
+        "onUpdate:modelValue": t[0] || (t[0] = (r) => l.value = r),
+        disabled: e.disabled
+      }, null, 8, ["modelValue", "disabled"])
+    ], 2));
+  }
+});
+export {
+  N as default
+};

package/dist/v2/features/command-palette/components/WatchModeToggle.vue2.js

@@ -0,0 +1,4 @@
+import f from "./WatchModeToggle.vue.js";
+export {
+  f as default
+};

package/dist/v2/features/command-palette/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TheCommandPalette } from './TheCommandPalette.vue.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/features/command-palette/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,yBAAyB,CAAA"}

package/dist/v2/features/command-palette/components/index.js

@@ -0,0 +1,4 @@
+import { default as t } from "./TheCommandPalette.vue.js";
+export {
+  t as TheCommandPalette
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Represents parsed details from an OpenAPI or Swagger specification.
+ * Used to display information about imported API descriptions in the command palette.
+ */
+export type OpenApiDocumentDetails = {
+    /** The API specification version (e.g., "OpenAPI 3.1.0" or "Swagger 2.0"). */
+    version: string;
+    /** The format of the specification document. */
+    type: 'json' | 'yaml';
+    /** The API title extracted from the info object, if available. */
+    title: string | undefined;
+};
+/**
+ * Extracts OpenAPI or Swagger specification details from a string.
+ * Attempts to parse as JSON first, then YAML if JSON parsing fails.
+ *
+ * Returns undefined if:
+ * - Input is null, empty, or a URL
+ * - Input is not a valid JSON or YAML document
+ * - Document does not contain OpenAPI or Swagger version information
+ */
+export declare const getOpenApiDocumentDetails: (input: string | null) => OpenApiDocumentDetails | undefined;
+//# sourceMappingURL=get-openapi-document-details.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-openapi-document-details.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-openapi-document-details.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAA;IACf,gDAAgD;IAChD,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,kEAAkE;IAClE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B,CAAA;AAmED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,GAAG,IAAI,KAAG,sBAAsB,GAAG,SAazF,CAAA"}

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

@@ -0,0 +1,31 @@
+import { json as n, yaml as a } from "@scalar/oas-utils/helpers";
+import { isUrl as l } from "../../../helpers/is-url.js";
+const e = (r) => typeof r?.title == "string" ? r.title : void 0, p = (r, t) => {
+  if (typeof r.openapi == "string")
+    return {
+      version: `OpenAPI ${r.openapi}`,
+      type: t,
+      title: e(r.info)
+    };
+  if (typeof r.swagger == "string")
+    return {
+      version: `Swagger ${r.swagger}`,
+      type: t,
+      title: e(r.info)
+    };
+}, s = (r, t, i) => {
+  try {
+    const o = t(r);
+    return p(o, i);
+  } catch {
+    return;
+  }
+}, c = (r) => {
+  if (!r || l(r))
+    return;
+  const t = s(r, n.parse, "json");
+  return t || s(r, a.parse, "yaml");
+};
+export {
+  c as getOpenApiDocumentDetails
+};

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

@@ -0,0 +1,13 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/**
+ * 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.
+ *
+ * @throws {Error} When the input is not valid JSON or when the conversion fails
+ * due to invalid Postman collection structure
+ */
+export declare const getOpenApiFromPostman: (postmanJson: string) => OpenAPIV3_1.Document;
+//# sourceMappingURL=get-openapi-from-postman.d.ts.map

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

@@ -0,0 +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":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,KAAG,WAAW,CAAC,QASvE,CAAA"}

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

@@ -0,0 +1,12 @@
+import { convert as t } from "@scalar/postman-to-openapi";
+const c = (o) => {
+  try {
+    return t(o);
+  } catch (r) {
+    const e = r instanceof Error ? r.message : "Unknown error";
+    throw new Error(`Failed to convert Postman collection to OpenAPI: ${e}`);
+  }
+};
+export {
+  c as getOpenApiFromPostman
+};

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

@@ -0,0 +1,26 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+import type { OperationObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+/**
+ * Represents the result of parsing a cURL command into an OpenAPI operation.
+ */
+type CurlOperationResult = {
+    /** The URL path extracted from the cURL command. */
+    path: string;
+    /** The HTTP method (GET, POST, etc.). */
+    method: HttpMethod;
+    /** The OpenAPI operation object with parameters, body, and servers. */
+    operation: OperationObject;
+};
+/**
+ * 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.
+ */
+export declare const getOperationFromCurl: (curl: string, exampleKey?: string) => CurlOperationResult;
+export {};
+//# sourceMappingURL=get-operation-from-curl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-operation-from-curl.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/get-operation-from-curl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,KAAK,EACV,eAAe,EAIhB,MAAM,8DAA8D,CAAA;AAIrE;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,yCAAyC;IACzC,MAAM,EAAE,UAAU,CAAA;IAClB,uEAAuE;IACvE,SAAS,EAAE,eAAe,CAAA;CAC3B,CAAA;AAuID;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,EAAE,mBAAmB,KAAG,mBAoCxE,CAAA"}

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

@@ -0,0 +1,70 @@
+import { parseCurlCommand as f } from "../../../../libs/parse-curl.js";
+const b = (t) => {
+  try {
+    return JSON.parse(t);
+  } catch {
+    const e = {};
+    return t.split("&").forEach((r) => {
+      const [n, o] = r.split("=");
+      n && o && (e[decodeURIComponent(n)] = decodeURIComponent(o));
+    }), e;
+  }
+}, j = (t, e) => {
+  if (e["Content-Type"])
+    return e["Content-Type"];
+  const r = t.trim();
+  return r.startsWith("{") || r.startsWith("[") ? "application/json" : t.includes("=") && !r.startsWith("{") ? "application/x-www-form-urlencoded" : "";
+}, a = (t) => {
+  const e = typeof t;
+  return e === "string" ? "string" : e === "number" ? "number" : e === "boolean" ? "boolean" : t === null ? "null" : Array.isArray(t) ? "array" : e === "object" ? "object" : "string";
+}, C = (t, e, r) => {
+  const n = Array.isArray(t) ? t.map(({ key: c, value: s }) => ({
+    name: c,
+    in: "query",
+    schema: { type: a(s) },
+    examples: {
+      [r]: { value: s }
+    }
+  })) : [], o = Object.entries(e || {}).map(([c, s]) => ({
+    name: c,
+    in: "header",
+    schema: { type: a(s) },
+    examples: {
+      [r]: { value: s }
+    }
+  }));
+  return [...n, ...o];
+}, g = (t) => ({
+  type: "object",
+  properties: Object.fromEntries(
+    Object.entries(t).map(([r, n]) => [r, { type: a(n) }])
+  )
+}), O = (t, e = "curl") => {
+  const r = f(t), { method: n = "get", url: o, body: c = "", headers: s = {}, servers: u = [], queryParameters: d = [] } = r, y = new URL(o).pathname, i = j(c, s), p = c ? b(c) : {}, l = C(d, s, e), m = u.map((h) => ({
+    url: h
+  }));
+  return {
+    path: y,
+    method: n,
+    operation: {
+      parameters: l,
+      requestBody: {
+        content: {
+          [i]: {
+            schema: g(p),
+            examples: {
+              [e]: { value: p }
+            }
+          }
+        },
+        "x-scalar-selected-content-type": {
+          [e]: i
+        }
+      },
+      servers: m.length ? m : void 0
+    }
+  };
+};
+export {
+  O as getOperationFromCurl
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Represents the extracted details from a Postman collection.
+ * Used to display collection metadata in the command palette import UI.
+ */
+export type PostmanDocumentDetails = {
+    /** The document format type. */
+    type: string;
+    /** The name of the Postman collection. */
+    title: string;
+    /** The version of the Postman collection. */
+    version: string;
+};
+/**
+ * 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
+ */
+export declare const getPostmanDocumentDetails: (content: string) => PostmanDocumentDetails | null;
+//# sourceMappingURL=get-postman-document-details.d.ts.map

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

@@ -0,0 +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,MAAM,MAAM,sBAAsB,GAAG;IACnC,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"}

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

@@ -0,0 +1,18 @@
+import { isPostmanCollection as o } from "./is-postman-collection.js";
+const r = (t) => {
+  if (!o(t))
+    return null;
+  try {
+    const n = JSON.parse(t);
+    return {
+      type: "json",
+      title: n.info?.name || "Postman Collection",
+      version: n.info?.version || "1.0"
+    };
+  } catch {
+    return null;
+  }
+};
+export {
+  r as getPostmanDocumentDetails
+};

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

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export declare const isPostmanCollection: (content: string) => boolean;
+//# sourceMappingURL=is-postman-collection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-postman-collection.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/helpers/is-postman-collection.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,OAWrD,CAAA"}

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

@@ -0,0 +1,11 @@
+const n = (o) => {
+  try {
+    const s = JSON.parse(o), t = s.info?._postman_id !== void 0, a = s.info?.schema && new URL(s.info.schema).host === "schema.getpostman.com";
+    return t && a;
+  } catch {
+    return !1;
+  }
+};
+export {
+  n as isPostmanCollection
+};