@scalar/api-client 2.11.0 → 2.13.0

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
+};

package/dist/v2/features/command-palette/hooks/use-command-palette-state.d.ts

@@ -0,0 +1,202 @@
+import type { Icon as IconType } from '@scalar/components';
+import { type ComputedRef, type Ref } from 'vue';
+import type { RouteLocationRaw } from 'vue-router';
+/** Base properties shared by all command types (internal) */
+type CommandBase = {
+    /** Unique identifier for the command */
+    id: string;
+    /** Display name shown in the command palette */
+    name: string;
+};
+type FolderCommand = CommandBase & {
+    type: 'folder';
+    icon: IconType;
+    /** Props for the command */
+    props?: Record<string, unknown>;
+};
+type HiddenFolderCommand = CommandBase & {
+    type: 'hidden-folder';
+    /** Props for the command */
+    props?: Record<string, unknown>;
+};
+type RouteCommand = CommandBase & {
+    type: 'route';
+    to: RouteLocationRaw;
+    icon: IconType;
+};
+/**
+ * Represents a single command in the command palette.
+ * Commands can be folders (open sub-actions), routes (navigate), or hidden folders.
+ */
+export type Command = FolderCommand | RouteCommand | HiddenFolderCommand;
+/**
+ * A group of related commands with a label.
+ * Used to organize commands into categories in the palette.
+ */
+export type CommandGroup = {
+    /** Label for the command group (empty string for unlabeled groups) */
+    label: string;
+    /** List of commands in this group */
+    commands: Command[];
+};
+/**
+ * Available commands in the command palette.
+ * Organized into groups for better UX and discoverability.
+ */
+export declare const commands: [{
+    readonly label: "";
+    readonly commands: [{
+        readonly type: "folder";
+        readonly id: "import-from-openapi-swagger-postman-curl";
+        readonly name: "Import from OpenAPI/Swagger/Postman/cURL";
+        readonly icon: "Import";
+    }, {
+        readonly type: "folder";
+        readonly id: "create-document";
+        readonly name: "Create Document";
+        readonly icon: "Collection";
+    }, {
+        readonly type: "folder";
+        readonly id: "add-tag";
+        readonly name: "Add Tag";
+        readonly icon: "Folder";
+    }, {
+        readonly type: "folder";
+        readonly id: "create-request";
+        readonly name: "Create Request";
+        readonly icon: "ExternalLink";
+    }, {
+        readonly type: "folder";
+        readonly id: "add-example";
+        readonly name: "Add Example";
+        readonly icon: "Example";
+    }, {
+        readonly type: "hidden-folder";
+        readonly id: "import-curl-command";
+        readonly name: "Import cURL Command";
+        readonly props: {
+            curl: string;
+        };
+    }];
+}, {
+    readonly label: "Pages";
+    readonly commands: [{
+        readonly type: "route";
+        readonly id: "environment";
+        readonly name: "Environment";
+        readonly icon: "Brackets";
+        readonly to: {
+            readonly name: "workspace.environment";
+        };
+    }, {
+        readonly type: "route";
+        readonly id: "cookies";
+        readonly name: "Cookies";
+        readonly icon: "Cookie";
+        readonly to: {
+            readonly name: "workspace.cookies";
+        };
+    }, {
+        readonly type: "route";
+        readonly id: "settings";
+        readonly name: "Settings";
+        readonly icon: "Settings";
+        readonly to: {
+            readonly name: "workspace.settings";
+        };
+    }];
+}];
+type FlatCommand = (typeof commands)[number]['commands'][number];
+export type FolderCommandIds = Extract<FlatCommand, {
+    type: 'folder';
+}>['id'];
+export type HiddenFolderCommandIds = Extract<FlatCommand, {
+    type: 'hidden-folder';
+}>['id'];
+/** Command IDs that map to UI components (folder and hidden-folder types) */
+export type UiCommandIds = FolderCommandIds | HiddenFolderCommandIds;
+/**
+ * Maps each command ID to its respective props type.
+ * If a command has no props defined, it maps to undefined.
+ *
+ * This is used by the type system to validate that command components
+ * accept the correct props for their respective command IDs.
+ */
+export type CommandPropsMap = {
+    [K in UiCommandIds]: Extract<FlatCommand, {
+        id: K;
+    }> extends {
+        props: infer P;
+    } ? P : undefined;
+};
+/**
+ * Type for the open function in the command palette.
+ * Supports two usage patterns:
+ * - open() - Opens the palette without a specific command
+ * - open(commandId) - Opens a command that does not require props
+ * - open(commandId, props) - Opens a command with required props
+ */
+export type OpenCommand = {
+    (): void;
+    <T extends UiCommandIds>(commandId: T, props: CommandPropsMap[T]): void;
+};
+export type OpenCommandEvent = <T extends UiCommandIds>(event: 'open-command', commandId: T, ...args: CommandPropsMap[T] extends undefined ? [] : [props: CommandPropsMap[T]]) => void;
+/**
+ * Return type for the useCommandPaletteState composable.
+ * Provides reactive state and methods to control the command palette.
+ */
+export type UseCommandPaletteStateReturn = {
+    /** Whether the command palette is currently open */
+    isOpen: Ref<boolean>;
+    /** The currently active command, or null if showing the main list */
+    activeCommand: Ref<UiCommandIds | null>;
+    /** Properties passed to the active command component */
+    activeCommandProps: Ref<Record<string, unknown> | null>;
+    /** Current filter/search query for filtering commands */
+    filterQuery: Ref<string>;
+    /** Filtered commands based on the current search query */
+    filteredCommands: ComputedRef<readonly CommandGroup[]>;
+    /**
+     * Opens the command palette, optionally with a specific command active.
+     * When opening a command, props are required only if the command defines them.
+     */
+    open: OpenCommand;
+    /** Closes the command palette and resets state */
+    close: () => void;
+    /** Updates the filter query for searching commands */
+    setFilterQuery: (query: string) => void;
+    /** Resets all state to initial values */
+    reset: () => void;
+};
+/**
+ * Composable for managing command palette state.
+ *
+ * Centralizes all state management for the command palette including:
+ * - Open/closed state
+ * - Filter/search query
+ * - Command filtering logic
+ *
+ * @example
+ * const palette = useCommandPaletteState()
+ *
+ * // Open the palette
+ * palette.open()
+ *
+ * // Open with a specific command
+ * palette.open('create-document')
+ *
+ * // Open with command props
+ * palette.open('import-curl-command', { curl: 'curl https://api.example.com' })
+ *
+ * // Update filter query (automatically filters commands)
+ * palette.setFilterQuery('import')
+ *
+ * // Access filtered results
+ * console.log(palette.filteredCommands.value)
+ *
+ * // Close and reset
+ * palette.close()
+ */
+export declare const useCommandPaletteState: () => UseCommandPaletteStateReturn;
+export {};
+//# sourceMappingURL=use-command-palette-state.d.ts.map

package/dist/v2/features/command-palette/hooks/use-command-palette-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-command-palette-state.d.ts","sourceRoot":"","sources":["../../../../../src/v2/features/command-palette/hooks/use-command-palette-state.ts"],"names":[],"mappings":"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"}

package/dist/v2/features/command-palette/hooks/use-command-palette-state.js

@@ -0,0 +1,109 @@
+import { useModal as y } from "@scalar/components";
+import { ref as m, computed as i } from "vue";
+const g = () => null, v = [
+  {
+    label: "",
+    commands: [
+      {
+        type: "folder",
+        id: "import-from-openapi-swagger-postman-curl",
+        name: "Import from OpenAPI/Swagger/Postman/cURL",
+        icon: "Import"
+      },
+      {
+        type: "folder",
+        id: "create-document",
+        name: "Create Document",
+        icon: "Collection"
+      },
+      {
+        type: "folder",
+        id: "add-tag",
+        name: "Add Tag",
+        icon: "Folder"
+      },
+      {
+        type: "folder",
+        id: "create-request",
+        name: "Create Request",
+        icon: "ExternalLink"
+      },
+      {
+        type: "folder",
+        id: "add-example",
+        name: "Add Example",
+        icon: "Example"
+      },
+      /** Hidden commands accessible programmatically but not shown in UI */
+      {
+        type: "hidden-folder",
+        id: "import-curl-command",
+        name: "Import cURL Command",
+        props: g()
+      }
+    ]
+  },
+  {
+    label: "Pages",
+    commands: [
+      {
+        type: "route",
+        id: "environment",
+        name: "Environment",
+        icon: "Brackets",
+        to: {
+          name: "workspace.environment"
+        }
+      },
+      {
+        type: "route",
+        id: "cookies",
+        name: "Cookies",
+        icon: "Cookie",
+        to: {
+          name: "workspace.cookies"
+        }
+      },
+      {
+        type: "route",
+        id: "settings",
+        name: "Settings",
+        icon: "Settings",
+        to: {
+          name: "workspace.settings"
+        }
+      }
+    ]
+  }
+], w = () => {
+  const n = y(), t = m(""), a = m(null), r = m(null), c = i(() => n.open), d = i(() => {
+    const e = t.value.toLowerCase().trim();
+    return v.map((o) => ({
+      label: o.label,
+      commands: o.commands.filter((s) => s.type === "hidden-folder" ? !1 : e ? s.name.toLowerCase().includes(e) : !0)
+    })).filter((o) => o.commands.length > 0);
+  }), p = (e, ...o) => {
+    e && (a.value = e, r.value = o[0] ?? null), n.show();
+  }, u = () => {
+    n.hide(), l();
+  }, f = (e) => {
+    t.value = e;
+  }, l = () => {
+    t.value = "", a.value = null, r.value = null;
+  };
+  return {
+    isOpen: c,
+    activeCommand: a,
+    activeCommandProps: r,
+    filterQuery: t,
+    filteredCommands: d,
+    open: p,
+    close: u,
+    setFilterQuery: f,
+    reset: l
+  };
+};
+export {
+  v as commands,
+  w as useCommandPaletteState
+};