@scalar/oas-utils 0.2.102 → 0.2.104

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/requests.d.ts

@@ -586,6 +586,4 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
 }>;
 export type Request = z.infer<typeof requestSchema>;
 export type RequestPayload = z.input<typeof requestSchema>;
-export type Operation = Request;
-export type OperationPayload = RequestPayload;
 //# sourceMappingURL=requests.d.ts.map

package/dist/entities/spec/requests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvC,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,oBAAoB,CAAA;AAI9E,eAAO,MAAM,cAAc,2FAUjB,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,0BAA0B;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG2B,CAAA;AA0BnD,8CAA8C;AAC9C,eAAO,MAAM,aAAa;IA3ExB;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;IAetB,eAAe;;IAEf,qBAAqB;;IAErB,kDAAkD;;IAElD,oCAAoC;;IAEpC,uDAAuD;;IAEvD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAA;AAE/B,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAG1D,MAAM,MAAM,SAAS,GAAG,OAAO,CAAA;AAC/B,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA"}
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvC,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,oBAAoB,CAAA;AAI9E,eAAO,MAAM,cAAc,2FAUjB,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG;IACzD,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,0BAA0B;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG2B,CAAA;AA0BnD,8CAA8C;AAC9C,eAAO,MAAM,aAAa;IA3ExB;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;IAEvB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEvB,sBAAsB;;;;;;IAetB,eAAe;;IAEf,qBAAqB;;IAErB,kDAAkD;;IAElD,oCAAoC;;IAEpC,uDAAuD;;IAEvD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlC,CAAA;AAE/B,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

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

@@ -0,0 +1,3 @@
+/** Ensure URL has a protocol prefix */
+export declare function ensureProtocol(url: string): string;
+//# sourceMappingURL=ensure-protocol.d.ts.map

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

@@ -0,0 +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,CAKlD"}

package/dist/helpers/ensure-protocol.js

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

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/index.d.ts

@@ -1,6 +1,7 @@
 export { isDefined } from './is-defined.js';
 export { shouldIgnoreEntity } from './shouldIgnoreEntity.js';
-export * from './concatenateUrlAndPath.js';
+export { combineUrlAndPath, mergeSearchParams, mergeUrls } from './merge-urls.js';
+export { ensureProtocol } from './ensure-protocol.js';
 export * from './createHash.js';
 export * from './fetchSpecFromUrl.js';
 export * from './fetchWithProxyFallback.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACzD,cAAc,yBAAyB,CAAA;AACvC,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,cAAc,cAAc,CAAA;AAC5B,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,cAAc,CAAA;AAC5B,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,2BAA2B,CAAA;AACzC,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA"}

package/dist/helpers/index.js

@@ -1,6 +1,7 @@
 export { isDefined } from './is-defined.js';
 export { shouldIgnoreEntity } from './shouldIgnoreEntity.js';
-export { concatenateUrlAndPath } from './concatenateUrlAndPath.js';
+export { combineUrlAndPath, mergeSearchParams, mergeUrls } from './merge-urls.js';
+export { ensureProtocol } from './ensure-protocol.js';
 export { createHash } from './createHash.js';
 export { fetchSpecFromUrl } from './fetchSpecFromUrl.js';
 export { fetchWithProxyFallback } from './fetchWithProxyFallback.js';

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

@@ -0,0 +1,15 @@
+/**
+ * Merges multiple URLSearchParams objects, preserving multiple values per param
+ * within each source, but later sources overwrite earlier ones completely
+ * This should de-dupe our query params while allowing multiple keys for "arrays"
+ */
+export declare const mergeSearchParams: (...params: URLSearchParams[]) => URLSearchParams;
+/** Combines a base URL and a path ensuring there's only one slash between them */
+export declare const combineUrlAndPath: (url: string, path: string) => string;
+/**
+ * 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
+ */
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,79 @@
+import { REGEX } from './regexHelpers.js';
+import { ensureProtocol } from './ensure-protocol.js';
+import { isRelativePath } from './redirectToProxy.js';
+
+/**
+ * Merges multiple URLSearchParams objects, preserving multiple values per param
+ * within each source, but later sources overwrite earlier ones completely
+ * This should de-dupe our query params while allowing multiple keys for "arrays"
+ */
+const mergeSearchParams = (...params) => {
+    // We keep a merged record to ensure the next group will overwrite the previous
+    const merged = {};
+    // Loops over each group and grabs unique keys
+    params.forEach((p) => {
+        const keys = Array.from(p.keys());
+        const uniqueKeys = new Set(keys);
+        uniqueKeys.forEach((key) => {
+            const values = p.getAll(key);
+            const value = values.length > 1 ? values : (values[0] ?? '');
+            merged[key] = value;
+        });
+    });
+    const result = new URLSearchParams();
+    // We maintain multiple values for each key if they existed
+    Object.entries(merged).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            value.forEach((v) => result.append(key, v));
+        }
+        else {
+            result.append(key, value);
+        }
+    });
+    return result;
+};
+/** Combines a base URL and a path ensuring there's only one slash between them */
+const combineUrlAndPath = (url, path) => {
+    if (!path || url === path)
+        return url.trim();
+    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(), 
+/** 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 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 || '');
+        // Extract search params from path if any
+        const [pathWithoutQuery = '', pathQuery] = path.split('?');
+        const pathParams = new URLSearchParams(pathQuery || '');
+        // Merge the baseUrl and path
+        const mergedUrl = url === path ? baseUrl : combineUrlAndPath(baseUrl, pathWithoutQuery);
+        // Merge all search params
+        const mergedSearchParams = mergeSearchParams(baseParams, pathParams, urlParams);
+        // Build the final URL
+        const search = mergedSearchParams.toString();
+        return search ? `${mergedUrl}?${search}` : mergedUrl;
+    }
+    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":"AAEA,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"}
+{"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

@@ -1,3 +1,4 @@
+import { REGEX } from './regexHelpers.js';
 import { isLocalUrl } from './isLocalUrl.js';
 
 /** Redirects the request to a proxy server with a given URL. */
@@ -15,8 +16,8 @@ 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://')) {
+    // Allow http:// https:// and other protocols such as file://
+    if (REGEX.PROTOCOL.test(url)) {
         return false;
     }
     // Check if it looks like a domain (contains dots and no spaces)

package/dist/helpers/regexHelpers.d.ts

@@ -1,4 +1,8 @@
 export declare const REGEX: {
+    /** 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;;;;CAIR,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,4 +1,8 @@
 const REGEX = {
+    /** 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;