@scalar/oas-utils 0.2.103 → 0.2.105

package/dist/entities/spec/request-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"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"}

package/dist/entities/spec/request-examples.js

@@ -13,7 +13,8 @@ import { getServerVariableExamples } from '../../spec-getters/getServerVariableE
  * The request schema should be stored in the request and any
  * parameters should be validated against that
  */
-const requestExampleParametersSchema = z.object({
+const requestExampleParametersSchema = z
+    .object({
     key: z.string().default(''),
     value: z.coerce.string().default(''),
     enabled: z.boolean().default(true),
@@ -22,12 +23,33 @@ const requestExampleParametersSchema = z.object({
     required: z.boolean().optional(),
     enum: z.array(z.string()).optional(),
     examples: z.array(z.string()).optional(),
-    type: z.string().optional(),
+    type: z
+        .union([
+        // 'string'
+        z.string(),
+        // ['string', 'null']
+        z.array(z.string()),
+    ])
+        .optional(),
     format: z.string().optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     default: z.any().optional(),
     nullable: z.boolean().optional(),
+})
+    // set nullable: to true if type is ['string', 'null']
+    .transform((data) => {
+    // type: ['string', 'null'] -> nullable: true
+    if (Array.isArray(data.type) && data.type.includes('null')) {
+        data = { ...data, nullable: true };
+    }
+    // Hey, if it’s just one value and 'null', we can make it a string and ditch the 'null'.
+    if (Array.isArray(data.type) &&
+        data.type.length === 2 &&
+        data.type.includes('null')) {
+        data = { ...data, type: data.type.find((item) => item !== 'null') };
+    }
+    return data;
 });
 /** Convert the array of parameters to an object keyed by the parameter name */
 function parameterArrayToObject(params) {
@@ -309,42 +331,51 @@ function createExampleFromRequest(request, name, server) {
                 requestBody: request.requestBody,
             },
         });
-        if (requestBody?.body?.mimeType === 'application/json') {
+        if (requestBody?.mimeType === 'application/json') {
             body.activeBody = 'raw';
             body.raw = {
                 encoding: 'json',
-                value: requestBody.body.text ?? JSON.stringify({}),
+                value: requestBody.text ?? JSON.stringify({}),
             };
         }
-        if (requestBody?.body?.mimeType === 'application/xml') {
+        if (requestBody?.mimeType === 'application/xml') {
             body.activeBody = 'raw';
             body.raw = {
                 encoding: 'xml',
-                value: requestBody.body.text ?? '',
+                value: requestBody.text ?? '',
             };
         }
         /**
          *  TODO: Are we loading example files from somewhere based on the spec?
          *  How are we handling the body values
          */
-        if (requestBody?.body?.mimeType === 'application/octet-stream') {
+        if (requestBody?.mimeType === 'application/octet-stream') {
             body.activeBody = 'binary';
             body.binary = undefined;
         }
-        if (requestBody?.body?.mimeType === 'application/x-www-form-urlencoded' ||
-            requestBody?.body?.mimeType === 'multipart/form-data') {
+        if (requestBody?.mimeType === 'application/x-www-form-urlencoded' ||
+            requestBody?.mimeType === 'multipart/form-data') {
             body.activeBody = 'formData';
             body.formData = {
-                encoding: requestBody.body.mimeType === 'application/x-www-form-urlencoded'
+                encoding: requestBody.mimeType === 'application/x-www-form-urlencoded'
                     ? 'urlencoded'
                     : 'form-data',
-                value: (requestBody.body.params || []).map((param) => ({
+                value: (requestBody.params || []).map((param) => ({
                     key: param.name,
                     value: param.value || '',
                     enabled: true,
                 })),
             };
         }
+        // Add the content-type header if it doesn't exist
+        if (requestBody?.mimeType &&
+            !parameters.headers.find((h) => h.key.toLowerCase() === 'content-type')) {
+            parameters.headers.push({
+                key: 'Content-Type',
+                value: requestBody.mimeType,
+                enabled: true,
+            });
+        }
     }
     const serverVariables = server ? getServerVariableExamples(server) : {};
     // safe parse the example
@@ -363,4 +394,4 @@ function createExampleFromRequest(request, name, server) {
         return example;
 }
 
-export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue };
+export { convertExampleToXScalar, createExampleFromRequest, createParamInstance, exampleBodyMime, exampleRequestBodyEncoding, exampleRequestBodySchema, parameterArrayToObject, requestExampleParametersSchema, requestExampleSchema, xScalarExampleBodySchema, xScalarExampleSchema, xScalarFileValueSchema, xScalarFormDataValue };

package/dist/entities/spec/spec-objects.js

@@ -40,7 +40,7 @@ const oasContactSchema = z.object({
  */
 const oasInfoSchema = z.object({
     /** REQUIRED. The title of the API. */
-    title: z.string().optional().default('OpenAPI Spec'),
+    title: z.string().optional().default('API'),
     /** A short summary of the API. */
     summary: z.string().optional(),
     /** A description of the API. CommonMark syntax MAY be used for rich text representation. */

package/dist/entities/workspace/workspace.d.ts

@@ -55,6 +55,17 @@ export declare const workspaceSchema: z.ZodObject<{
     proxyUrl: z.ZodOptional<z.ZodString>;
     /** Workspace level theme, we might move this to user level later */
     themeId: z.ZodDefault<z.ZodOptional<z.ZodEnum<["alternate", "default", "moon", "purple", "solarized", "bluePlanet", "deepSpace", "saturn", "kepler", "elysiajs", "fastify", "mars", "none"]>>>;
+    /** Currently selected snippet client */
+    selectedHttpClient: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        targetKey: z.ZodString;
+        clientKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        targetKey: string;
+        clientKey: string;
+    }, {
+        targetKey: string;
+        clientKey: string;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     uid: string;
     name: string;
@@ -64,6 +75,10 @@ export declare const workspaceSchema: z.ZodObject<{
     activeEnvironmentId: string;
     cookies: string[];
     themeId: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "none";
+    selectedHttpClient: {
+        targetKey: string;
+        clientKey: string;
+    };
     hotKeyConfig?: {
         modifiers: ("Meta" | "Control" | "Shift" | "Alt" | "default")[];
         hotKeys?: Partial<Record<"" | "/" | "Space" | "Backspace" | "Tab" | "Enter" | "Escape" | "ArrowDown" | "ArrowLeft" | "ArrowRight" | "ArrowUp" | "End" | "Home" | "PageDown" | "PageUp" | "Delete" | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "*" | "+" | "-" | "." | "F1" | "F2" | "F3" | "F4" | "F5" | "F6" | "F7" | "F8" | "F9" | "F10" | "F11" | "F12" | ";" | "=" | "," | "`" | "[" | "\\" | "]", {
@@ -89,6 +104,10 @@ export declare const workspaceSchema: z.ZodObject<{
     cookies?: string[] | undefined;
     proxyUrl?: string | undefined;
     themeId?: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "none" | undefined;
+    selectedHttpClient?: {
+        targetKey: string;
+        clientKey: string;
+    } | undefined;
 }>;
 /** The base scalar workspace */
 export type Workspace = z.infer<typeof workspaceSchema>;

package/dist/entities/workspace/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/entities/workspace/workspace.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,QAAA,MAAM,SAAS,yIAAoD,CAAA;AAEnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEvD,QAAA,MAAM,OAAO;;;;;;;;;GAMZ,CAAA;AACD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AASlD,eAAO,MAAM,eAAe;;;IAG1B,4BAA4B;;IAE5B,uDAAuD;;IAEvD,wDAAwD;;IAExD,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;IAExB,iDAAiD;;IAEjD,mDAAmD;;IAEnD,gEAAgE;;IAEhE,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpE,CAAA;AAEF,gCAAgC;AAChC,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/entities/workspace/workspace.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,QAAA,MAAM,SAAS,yIAAoD,CAAA;AAEnE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA;AAEvD,QAAA,MAAM,OAAO;;;;;;;;;GAMZ,CAAA;AACD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AASlD,eAAO,MAAM,eAAe;;;IAG1B,4BAA4B;;IAE5B,uDAAuD;;IAEvD,wDAAwD;;IAExD,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;IAExB,iDAAiD;;IAEjD,mDAAmD;;IAEnD,gEAAgE;;IAEhE,oEAAoE;;IAEpE,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWxC,CAAA;AAEF,gCAAgC;AAChC,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AACvD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/entities/workspace/workspace.js

@@ -37,6 +37,17 @@ const workspaceSchema = z.object({
     proxyUrl: z.string().optional(),
     /** Workspace level theme, we might move this to user level later */
     themeId: z.enum(themeIds).optional().default('default'),
+    /** Currently selected snippet client */
+    selectedHttpClient: z
+        .object({
+        targetKey: z.string(),
+        clientKey: z.string(),
+    })
+        .optional()
+        .default({
+        targetKey: 'shell',
+        clientKey: 'curl',
+    }),
 });
 
 export { workspaceSchema };

package/dist/helpers/ensure-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensure-protocol.d.ts","sourceRoot":"","sources":["../../src/helpers/ensure-protocol.ts"],"names":[],"mappings":"AAEA,uCAAuC;AACvC,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAMlD"}
+{"version":3,"file":"ensure-protocol.d.ts","sourceRoot":"","sources":["../../src/helpers/ensure-protocol.ts"],"names":[],"mappings":"AAEA,uCAAuC;AACvC,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKlD"}

package/dist/helpers/ensure-protocol.js

@@ -2,9 +2,8 @@ import { REGEX } from './regexHelpers.js';
 
 /** Ensure URL has a protocol prefix */
 function ensureProtocol(url) {
-    if (REGEX.PATH.test(url) || REGEX.PROTOCOL.test(url)) {
+    if (REGEX.PROTOCOL.test(url))
         return url;
-    }
     // Default to http if no protocol is specified
     return `http://${url.replace(/^\//, '')}`;
 }

package/dist/helpers/fetchWithProxyFallback.d.ts

@@ -1,5 +1,5 @@
 export type FetchWithProxyFallbackOptions = {
-    proxy?: string;
+    proxy: string | undefined;
     /**
      * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
      */

package/dist/helpers/fetchWithProxyFallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchWithProxyFallback.d.ts","sourceRoot":"","sources":["../../src/helpers/fetchWithProxyFallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;OAEG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAC7B,CAAA;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,6BAA6B,qBAwBhD"}
+{"version":3,"file":"fetchWithProxyFallback.d.ts","sourceRoot":"","sources":["../../src/helpers/fetchWithProxyFallback.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAC7B,CAAA;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,MAAM,EACX,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,6BAA6B,qBAwBhD"}

package/dist/helpers/merge-urls.d.ts

@@ -11,5 +11,5 @@ export declare const combineUrlAndPath: (url: string, path: string) => string;
  * also optionally merges query params if you include urlSearchParams
  * This was re-written without using URL to support variables in the scheme
  */
-export declare const mergeUrls: (url: string, path: string, urlParams?: URLSearchParams) => string;
+export declare const mergeUrls: (url: string, path: string, urlParams?: URLSearchParams, disableOriginPrefix?: boolean) => string;
 //# sourceMappingURL=merge-urls.d.ts.map

package/dist/helpers/merge-urls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-urls.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-urls.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,cACjB,eAAe,EAAE,KAC3B,eA6BF,CAAA;AAED,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,QAAS,MAAM,QAAQ,MAAM,WAQ1D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,QACf,MAAM,QACL,MAAM,cACD,eAAe,WAiC3B,CAAA"}
+{"version":3,"file":"merge-urls.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-urls.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,cACjB,eAAe,EAAE,KAC3B,eA6BF,CAAA;AAED,kFAAkF;AAClF,eAAO,MAAM,iBAAiB,QAAS,MAAM,QAAQ,MAAM,WAM1D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,SAAS,QACf,MAAM,QACL,MAAM,cACD,eAAe,0CAuC3B,CAAA"}

package/dist/helpers/merge-urls.js

@@ -1,3 +1,4 @@
+import { REGEX } from './regexHelpers.js';
 import { ensureProtocol } from './ensure-protocol.js';
 import { isRelativePath } from './redirectToProxy.js';
 
@@ -35,23 +36,26 @@ const mergeSearchParams = (...params) => {
 const combineUrlAndPath = (url, path) => {
     if (!path || url === path)
         return url.trim();
-    // Remove trailing slash from url and leading slash from path
-    const cleanBase = url.replace(/\/+$/, '').trim();
-    const cleanPath = path.replace(/^\/+/, '').trim();
-    return `${cleanBase}/${cleanPath}`;
+    if (!url)
+        return path.trim();
+    return `${url.trim()}/${path.trim()}`.replace(REGEX.MULTIPLE_SLASHES, '/');
 };
 /**
  * Creates a URL from the path and server
  * also optionally merges query params if you include urlSearchParams
  * This was re-written without using URL to support variables in the scheme
  */
-const mergeUrls = (url, path, urlParams = new URLSearchParams()) => {
+const mergeUrls = (url, path, urlParams = new URLSearchParams(), 
+/** To disable prefixing the url with the origin or a scheme*/
+disableOriginPrefix = false) => {
     // Extract and merge all query params
     if (url && (!isRelativePath(url) || typeof window !== 'undefined')) {
-        /** Prefix the url with the origin if it is relative */
-        const base = isRelativePath(url)
-            ? combineUrlAndPath(window.location.origin, url)
-            : ensureProtocol(url);
+        /** Prefix the url with the origin if it is relative and we wish to */
+        const base = disableOriginPrefix
+            ? url
+            : isRelativePath(url)
+                ? combineUrlAndPath(window.location.origin, url)
+                : ensureProtocol(url);
         // Extract search params from base URL if any
         const [baseUrl = '', baseQuery] = base.split('?');
         const baseParams = new URLSearchParams(baseQuery || '');
@@ -66,7 +70,10 @@ const mergeUrls = (url, path, urlParams = new URLSearchParams()) => {
         const search = mergedSearchParams.toString();
         return search ? `${mergedUrl}?${search}` : mergedUrl;
     }
-    return url;
+    else if (path) {
+        return combineUrlAndPath(url, path);
+    }
+    return '';
 };
 
 export { combineUrlAndPath, mergeSearchParams, mergeUrls };

package/dist/helpers/redirectToProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redirectToProxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirectToProxy.ts"],"names":[],"mappings":"AAIA,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAepE;AAED,wEAAwE;AACxE,eAAO,MAAM,cAAc,QAAS,MAAM,YAkBzC,CAAA;AAED,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAWpE"}
+{"version":3,"file":"redirectToProxy.d.ts","sourceRoot":"","sources":["../../src/helpers/redirectToProxy.ts"],"names":[],"mappings":"AAIA,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAepE;AAED,wEAAwE;AACxE,eAAO,MAAM,cAAc,QAAS,MAAM,YAazC,CAAA;AAED,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAWpE"}

package/dist/helpers/redirectToProxy.js

@@ -16,11 +16,7 @@ function redirectToProxy(proxy, url) {
 }
 /** Check if the URL is relative or if it's a domain without protocol */
 const isRelativePath = (url) => {
-    // Absolute URLs start with http:// or https://
-    if (url.startsWith('http://') || url.startsWith('https://')) {
-        return false;
-    }
-    // Allow other protocols such as file://
+    // Allow http:// https:// and other protocols such as file://
     if (REGEX.PROTOCOL.test(url)) {
         return false;
     }

package/dist/helpers/regexHelpers.d.ts

@@ -1,6 +1,8 @@
 export declare const REGEX: {
-    /** Checks if the url starts with a protocol like file:// including {variable}:// */
+    /** Checks for a valid scheme */
     readonly PROTOCOL: RegExp;
+    /** Finds multiple slashes after the scheme to replace with a single slash */
+    readonly MULTIPLE_SLASHES: RegExp;
     readonly VARIABLES: RegExp;
     readonly PATH: RegExp;
     readonly TEMPLATE_VARIABLE: RegExp;

package/dist/helpers/regexHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regexHelpers.d.ts","sourceRoot":"","sources":["../../src/helpers/regexHelpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;IAChB,oFAAoF;;;;;CAK5E,CAAA"}
+{"version":3,"file":"regexHelpers.d.ts","sourceRoot":"","sources":["../../src/helpers/regexHelpers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK;IAChB,gCAAgC;;IAEhC,6EAA6E;;;;;CAKrE,CAAA"}

package/dist/helpers/regexHelpers.js

@@ -1,6 +1,8 @@
 const REGEX = {
-    /** Checks if the url starts with a protocol like file:// including {variable}:// */
-    PROTOCOL: /^[a-zA-Z{}][a-zA-Z0-9+.{}-]*:\/\//,
+    /** Checks for a valid scheme */
+    PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\/\//,
+    /** Finds multiple slashes after the scheme to replace with a single slash */
+    MULTIPLE_SLASHES: /(?<!:)\/{2,}/g,
     VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,
     PATH: /(?:{)([^{}]+)}(?!})/g,
     TEMPLATE_VARIABLE: /{{\s*([^}\s]+?)\s*}}|{\s*([^}\s]+?)\s*}|:\b[\w.]+\b/g,

package/dist/migrations/v-2.5.0/migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.5.0/migration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AAEnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD,mCAAmC;AACnC,eAAO,MAAM,eAAe,SACpB,OAAO,CAAC,UAAU,KACvB,OAAO,CAAC,UAgEV,CAAA"}
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.5.0/migration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AAEnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAEhD,mCAAmC;AACnC,eAAO,MAAM,eAAe,SACpB,OAAO,CAAC,UAAU,KACvB,OAAO,CAAC,UA8EV,CAAA"}

package/dist/migrations/v-2.5.0/migration.js

@@ -36,10 +36,21 @@ const migrate_v_2_5_0 = (data) => {
         };
         return acc;
     }, {});
+    const workspaces = Object.entries(data.workspaces || {}).reduce((acc, [key, workspace]) => {
+        acc[key] = {
+            ...workspace,
+            selectedHttpClient: {
+                targetKey: 'shell',
+                clientKey: 'curl',
+            },
+        };
+        return acc;
+    }, {});
     return {
         ...data,
         requestExamples,
         servers,
+        workspaces,
     };
 };
 

package/dist/spec-getters/getRequestBodyFromOperation.d.ts

@@ -4,18 +4,12 @@ declare const mimeTypes: readonly ["application/json", "application/octet-stream
  * Get the request body from the operation.
  */
 export declare function getRequestBodyFromOperation(operation: Omit<TransformedOperation, 'httpVerb'>, selectedExampleKey?: string | number, omitEmptyAndOptionalProperties?: boolean): {
-    headers?: {
+    mimeType: (typeof mimeTypes)[number];
+    text?: string;
+    params?: {
         name: string;
-        value: string;
+        value?: string;
     }[];
-    body?: {
-        mimeType: (typeof mimeTypes)[number];
-        text?: string;
-        params?: {
-            name: string;
-            value?: string;
-        }[];
-    };
 } | null;
 export {};
 //# sourceMappingURL=getRequestBodyFromOperation.d.ts.map

package/dist/spec-getters/getRequestBodyFromOperation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRequestBodyFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getRequestBodyFromOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAgC7E,QAAA,MAAM,SAAS,wJAOL,CAAA;AAEV;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EACjD,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,EACpC,8BAA8B,CAAC,EAAE,OAAO,GACvC;IACD,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IAC3C,IAAI,CAAC,EAAE;QACL,QAAQ,EAAE,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAA;QACpC,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE;YACP,IAAI,EAAE,MAAM,CAAA;YACZ,KAAK,CAAC,EAAE,MAAM,CAAA;SACf,EAAE,CAAA;KACJ,CAAA;CACF,GAAG,IAAI,CA6MP"}
+{"version":3,"file":"getRequestBodyFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getRequestBodyFromOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAgC7E,QAAA,MAAM,SAAS,wJAOL,CAAA;AAEV;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EACjD,kBAAkB,CAAC,EAAE,MAAM,GAAG,MAAM,EACpC,8BAA8B,CAAC,EAAE,OAAO,GACvC;IACD,QAAQ,EAAE,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAA;IACpC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,EAAE,CAAA;CACJ,GAAG,IAAI,CAkLP"}

package/dist/spec-getters/getRequestBodyFromOperation.js

@@ -39,17 +39,15 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
      * TODO: This is very fragile. There needs to be significantly more support for
      * vendor specific content types (like application/vnd.github+json)
      */
-    const mimeType = mimeTypes.find((currentMimeType) => !!content?.[currentMimeType]);
+    const mimeType = mimeTypes.find((currentMimeType) => !!content?.[currentMimeType]) ?? 'application/json';
     /** Examples */
-    const examples = content?.['application/json']?.examples;
+    const examples = content?.[mimeType]?.examples ?? content?.['application/json']?.examples;
     // Let’s use the first example
     const selectedExample = (examples ?? {})?.[selectedExampleKey ?? Object.keys(examples ?? {})[0]];
     if (selectedExample) {
         return {
-            body: {
-                mimeType: 'application/json',
-                text: prettyPrintJson(selectedExample?.value),
-            },
+            mimeType,
+            text: prettyPrintJson(selectedExample?.value),
         };
     }
     /**
@@ -63,10 +61,8 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
     const bodyParameters = getParametersFromOperation(operation, 'body', false);
     if (bodyParameters.length > 0) {
         return {
-            body: {
-                mimeType: 'application/json',
-                text: prettyPrintJson(bodyParameters[0].value),
-            },
+            mimeType: 'application/json',
+            text: prettyPrintJson(bodyParameters[0].value),
         };
     }
     /**
@@ -88,21 +84,19 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
     const formDataParameters = getParametersFromOperation(operation, 'formData', false);
     if (formDataParameters.length > 0) {
         return {
-            body: {
-                mimeType: 'application/x-www-form-urlencoded',
-                params: formDataParameters.map((parameter) => ({
-                    name: parameter.name,
-                    /**
-                     * TODO: This value MUST be a string
-                     * Figure out why this is not always a string
-                     *
-                     * JSON.stringify is a TEMPORARY fix
-                     */
-                    value: typeof parameter.value === 'string'
-                        ? parameter.value
-                        : JSON.stringify(parameter.value),
-                })),
-            },
+            mimeType: 'application/x-www-form-urlencoded',
+            params: formDataParameters.map((parameter) => ({
+                name: parameter.name,
+                /**
+                 * TODO: This value MUST be a string
+                 * Figure out why this is not always a string
+                 *
+                 * JSON.stringify is a TEMPORARY fix
+                 */
+                value: typeof parameter.value === 'string'
+                    ? parameter.value
+                    : JSON.stringify(parameter.value),
+            })),
         };
     }
     // If no mime type is supported, exit early
@@ -111,13 +105,6 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
     }
     // Get the request body object for the mime type
     const requestBodyObject = content?.[mimeType];
-    // Define the appropriate Content-Type headers
-    const headers = [
-        {
-            name: 'Content-Type',
-            value: mimeType,
-        },
-    ];
     // Get example from operation
     const example = requestBodyObject?.example
         ? requestBodyObject?.example
@@ -132,11 +119,8 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
             : null;
         const body = example ?? exampleFromSchema;
         return {
-            headers,
-            body: {
-                mimeType: mimeType,
-                text: typeof body === 'string' ? body : JSON.stringify(body, null, 2),
-            },
+            mimeType,
+            text: typeof body === 'string' ? body : JSON.stringify(body, null, 2),
         };
     }
     // XML
@@ -148,21 +132,15 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
             })
             : null;
         return {
-            headers,
-            body: {
-                mimeType: mimeType,
-                text: example ?? json2xml(exampleFromSchema, '  '),
-            },
+            mimeType,
+            text: example ?? json2xml(exampleFromSchema, '  '),
         };
     }
     // Binary data
     if (mimeType === 'application/octet-stream') {
         return {
-            headers,
-            body: {
-                mimeType: mimeType,
-                text: 'BINARY',
-            },
+            mimeType,
+            text: 'BINARY',
         };
     }
     // Plain text
@@ -174,11 +152,8 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
             })
             : null;
         return {
-            headers,
-            body: {
-                mimeType: mimeType,
-                text: example ?? exampleFromSchema ?? '',
-            },
+            mimeType,
+            text: example ?? exampleFromSchema ?? '',
         };
     }
     // URL encoded data
@@ -191,11 +166,8 @@ function getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAnd
             })
             : null;
         return {
-            headers,
-            body: {
-                mimeType: mimeType,
-                params: getParamsFromObject(example ?? exampleFromSchema ?? {}),
-            },
+            mimeType,
+            params: getParamsFromObject(example ?? exampleFromSchema ?? {}),
         };
     }
     return null;

package/dist/transforms/import-spec.d.ts

@@ -16,9 +16,7 @@ export declare const parseSchema: (spec: string | UnknownObject, { shouldLoad }?
     errors: import("@scalar/openapi-parser").ErrorObject[];
 }>;
 /** Converts selected security requirements to uids */
-export declare const getSelectedSecuritySchemeUids: (securityRequirements: SelectedSecuritySchemeUids, authentication: {
-    preferredSecurityScheme?: string | null;
-} | undefined, securitySchemeMap: Record<string, string>) => SelectedSecuritySchemeUids;
+export declare const getSelectedSecuritySchemeUids: (securityRequirements: SelectedSecuritySchemeUids, authentication: ReferenceConfiguration["authentication"] | undefined, securitySchemeMap: Record<string, string>) => SelectedSecuritySchemeUids;
 export type ImportSpecToWorkspaceArgs = Pick<CollectionPayload, 'documentUrl' | 'watchMode'> & Pick<ReferenceConfiguration, 'authentication' | 'baseServerURL' | 'servers'> & {
     /** Sets the preferred security scheme on the collection instead of the requests */
     setCollectionSecurity?: boolean;

package/dist/transforms/import-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,cAAc,EAGnB,KAAK,MAAM,EACX,KAAK,GAAG,EAMT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,0BAA0B,CAAA;AAWjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxD,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAChB,MAAM,GAAG,aAAa;;;IAuC1B;;;OAGG;YAC8C,WAAW,CAAC,QAAQ;;EAGxE,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,6BAA6B,yBAClB,0BAA0B,kBAChC;IAAE,uBAAuB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,SAAS,qBACpD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACxC,0BAYF,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,aAAa,GAAG,WAAW,CAC5B,GACC,IAAI,CACF,sBAAsB,EACtB,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAC/C,GAAG;IACF,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,yCAAyC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,aAAa,EACb,WAAW,EACX,OAAO,EAAE,iBAAiB,EAC1B,qBAA6B,EAC7B,UAAU,EACV,SAAiB,GAClB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC5B,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAC5C,CA4UA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,GAAG,SAAS,EAC/C,EAAE,aAAa,EAAE,GAAE,IAAI,CAAC,sBAAsB,EAAE,eAAe,CAAM,GACpE,MAAM,EAAE,CA8CV"}
+{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,cAAc,EAGnB,KAAK,MAAM,EACX,KAAK,GAAG,EAMT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,0BAA0B,CAAA;AAWjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxD,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAChB,MAAM,GAAG,aAAa;;;IAuC1B;;;OAGG;YAC8C,WAAW,CAAC,QAAQ;;EAGxE,CAAA;AAED,sDAAsD;AACtD,eAAO,MAAM,6BAA6B,yBAClB,0BAA0B,kBAChC,sBAAsB,CAAC,gBAAgB,CAAC,GAAG,SAAS,qBACjD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACxC,0BAgCF,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,iBAAiB,EACjB,aAAa,GAAG,WAAW,CAC5B,GACC,IAAI,CACF,sBAAsB,EACtB,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAC/C,GAAG;IACF,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,yCAAyC;IACzC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,aAAa,EACb,WAAW,EACX,OAAO,EAAE,iBAAiB,EAC1B,qBAA6B,EAC7B,UAAU,EACV,SAAiB,GAClB,GAAE,yBAA8B,GAChC,OAAO,CACN;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC5B,QAAQ,EAAE,cAAc,EAAE,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe,EAAE,cAAc,EAAE,CAAA;CAClC,GACD;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAC5C,CA6UA;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,GAAG,SAAS,EAC/C,EAAE,aAAa,EAAE,GAAE,IAAI,CAAC,sBAAsB,EAAE,eAAe,CAAM,GACpE,MAAM,EAAE,CA8CV"}

package/dist/transforms/import-spec.js

@@ -52,14 +52,31 @@ const parseSchema = async (spec, { shouldLoad = true } = {}) => {
 };
 /** Converts selected security requirements to uids */
 const getSelectedSecuritySchemeUids = (securityRequirements, authentication, securitySchemeMap) => {
-    const name = authentication?.preferredSecurityScheme &&
-        securityRequirements.includes(authentication.preferredSecurityScheme)
-        ? authentication.preferredSecurityScheme
-        : securityRequirements[0];
-    const uids = Array.isArray(name)
+    // Filter the preferred security schemes to only include the ones that are in the security requirements
+    const preferredSecurityNames = [
+        authentication?.preferredSecurityScheme ?? [],
+    ]
+        .flat()
+        .filter((name) => {
+        // Match up complex security requirements, array to array
+        if (Array.isArray(name)) {
+            // We match every element in the array
+            return securityRequirements.some((r) => Array.isArray(r) &&
+                r.length === name.length &&
+                r.every((v, i) => v === name[i]));
+        }
+        else
+            return securityRequirements.includes(name);
+    });
+    // Set the first security requirement if no preferred security schemes are set
+    if (!preferredSecurityNames.length && securityRequirements[0]) {
+        preferredSecurityNames.push(securityRequirements[0]);
+    }
+    // Map names to uids
+    const uids = preferredSecurityNames.map((name) => Array.isArray(name)
         ? name.map((k) => securitySchemeMap[k])
-        : securitySchemeMap[name];
-    return [uids];
+        : securitySchemeMap[name]);
+    return uids;
 };
 /**
  * Imports an OpenAPI document and converts it to workspace entities (Collection, Request, Server, etc.)
@@ -203,6 +220,7 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
                 ...operationWithoutSecurity,
                 method,
                 path: pathString,
+                security: operationSecurity,
                 selectedSecuritySchemeUids,
                 // Merge path and operation level parameters
                 parameters: [