@scalar/oas-utils 0.2.84 → 0.2.86

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @scalar/oas-utils
 
+## 0.2.86
+
+### Patch Changes
+
+- 3eb0d11: feat: moved api-client auth into references
+- b66a85c: feat: adds v-2.3.0 migration for workspace type
+
+## 0.2.85
+
+### Patch Changes
+
+- 3b4a788: feat: sets form request examples defaulting
+- 4c5be96: feat: adds isHttpMethod to helpers
+- 4c5be96: fix: sorts method based on path in import spec
+
 ## 0.2.84
 
 ### Patch Changes

package/dist/entities/spec/collection.d.ts

@@ -97,7 +97,7 @@ export declare const oasCollectionSchema: z.ZodObject<{
     webhooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     /** A custom icon representing the collection */
     'x-scalar-icon': z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    'x-scalar-environment': z.ZodOptional<z.ZodString>;
+    'x-scalar-active-environment': z.ZodOptional<z.ZodString>;
     'x-scalar-environments': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
@@ -165,7 +165,7 @@ export declare const oasCollectionSchema: z.ZodObject<{
     } | undefined;
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
-    'x-scalar-environment'?: string | undefined;
+    'x-scalar-active-environment'?: string | undefined;
     'x-scalar-environments'?: Record<string, {
         variables: Record<string, string | {
             default: string;
@@ -207,7 +207,7 @@ export declare const oasCollectionSchema: z.ZodObject<{
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
     'x-scalar-icon'?: string | undefined;
-    'x-scalar-environment'?: string | undefined;
+    'x-scalar-active-environment'?: string | undefined;
     'x-scalar-environments'?: Record<string, {
         variables: Record<string, string | {
             default?: string | undefined;
@@ -378,7 +378,7 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
     webhooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     /** A custom icon representing the collection */
     'x-scalar-icon': z.ZodDefault<z.ZodOptional<z.ZodString>>;
-    'x-scalar-environment': z.ZodOptional<z.ZodString>;
+    'x-scalar-active-environment': z.ZodOptional<z.ZodString>;
     'x-scalar-environments': z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         color: z.ZodOptional<z.ZodString>;
@@ -488,7 +488,7 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
     } | undefined;
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
-    'x-scalar-environment'?: string | undefined;
+    'x-scalar-active-environment'?: string | undefined;
     'x-scalar-environments'?: Record<string, {
         variables: Record<string, string | {
             default: string;
@@ -534,7 +534,7 @@ export declare const collectionSchema: z.ZodObject<z.objectUtil.extendShape<{
     components?: Record<string, unknown> | undefined;
     webhooks?: Record<string, unknown> | undefined;
     'x-scalar-icon'?: string | undefined;
-    'x-scalar-environment'?: string | undefined;
+    'x-scalar-active-environment'?: string | undefined;
     'x-scalar-environments'?: Record<string, {
         variables: Record<string, string | {
             default?: string | undefined;

package/dist/entities/spec/collection.js

@@ -38,7 +38,7 @@ const oasCollectionSchema = z.object({
     'webhooks': z.record(z.string(), z.unknown()).optional(),
     /** A custom icon representing the collection */
     'x-scalar-icon': z.string().optional().default('interface-content-folder'),
-    'x-scalar-environment': z.string().optional(),
+    'x-scalar-active-environment': z.string().optional(),
     'x-scalar-environments': xScalarEnvironmentsSchema.optional(),
     'x-scalar-secrets': xScalarSecretsSchema.optional(),
     // These properties will be stripped out and mapped back as id lists

package/dist/entities/spec/index.d.ts

@@ -5,6 +5,7 @@ export * from './request-examples.js';
 export * from './spec-objects.js';
 export * from './parameters.js';
 export * from './security.js';
+export * from './x-scalar-environments.js';
 type FetchRequest = Request;
 export type { FetchRequest };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAE1B,KAAK,YAAY,GAAG,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,yBAAyB,CAAA;AAEvC,KAAK,YAAY,GAAG,OAAO,CAAA;AAC3B,YAAY,EAAE,YAAY,EAAE,CAAA"}

package/dist/entities/spec/index.js

@@ -5,3 +5,4 @@ export { convertExampleToXScalar, createExampleFromRequest, createParamInstance,
 export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, oasTagSchema, tagSchema, xScalarNestedSchema } from './spec-objects.js';
 export { oasParameterSchema, parameterStyleSchema, parameterTypeSchema } from './parameters.js';
 export { oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeApiKeyIn, securitySchemeSchema } from './security.js';
+export { xScalarEnvVarSchema, xScalarEnvironmentSchema, xScalarEnvironmentsSchema } from './x-scalar-environments.js';

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

@@ -325,12 +325,19 @@ function createExampleFromRequest(request, name, server) {
             body.activeBody = 'binary';
             body.binary = undefined;
         }
-        /**
-         * TODO: How are handling form data examples from the spec
-         */
-        if (requestBody?.body?.mimeType === 'application/x-www-form-urlencoded') {
+        if (requestBody?.body?.mimeType === 'application/x-www-form-urlencoded' ||
+            requestBody?.body?.mimeType === 'multipart/form-data') {
             body.activeBody = 'formData';
-            body.formData = undefined;
+            body.formData = {
+                encoding: requestBody.body.mimeType === 'application/x-www-form-urlencoded'
+                    ? 'urlencoded'
+                    : 'form-data',
+                value: (requestBody.body.params || []).map((param) => ({
+                    key: param.name,
+                    value: param.value || '',
+                    enabled: true,
+                })),
+            };
         }
     }
     const serverVariables = server ? getServerVariableExamples(server) : {};

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

@@ -551,7 +551,6 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
     deprecated?: boolean | undefined;
     examples?: (string | undefined)[] | undefined;
     operationId?: string | undefined;
-    method?: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace" | undefined;
     parameters?: {
         name: string;
         in: "path" | "query" | "header" | "cookie";
@@ -569,6 +568,7 @@ export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
     }[] | undefined;
     requestBody?: any;
     responses?: Record<string, any> | undefined;
+    method?: "options" | "connect" | "delete" | "get" | "head" | "patch" | "post" | "put" | "trace" | undefined;
 }>;
 export type Request = z.infer<typeof requestSchema>;
 export type RequestPayload = z.input<typeof requestSchema>;

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

@@ -20,7 +20,7 @@ export declare const workspaceSchema: z.ZodObject<{
     /** List of all collection uids in a given workspace */
     collections: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     /** List of all environment uids in a given workspace */
-    environments: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     /** Customize hotkeys */
     hotKeyConfig: z.ZodOptional<z.ZodObject<{
         modifiers: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodEnum<["Meta", "Control", "Shift", "Alt", "default"]>>>, "many">>>;
@@ -60,7 +60,7 @@ export declare const workspaceSchema: z.ZodObject<{
     name: string;
     description: string;
     collections: string[];
-    environments: string[];
+    environments: Record<string, string>;
     activeEnvironmentId: string;
     cookies: string[];
     themeId: "default" | "alternate" | "moon" | "purple" | "solarized" | "bluePlanet" | "deepSpace" | "saturn" | "kepler" | "elysiajs" | "fastify" | "mars" | "none";
@@ -77,7 +77,7 @@ export declare const workspaceSchema: z.ZodObject<{
     name?: string | undefined;
     description?: string | undefined;
     collections?: string[] | undefined;
-    environments?: string[] | undefined;
+    environments?: Record<string, string> | undefined;
     hotKeyConfig?: {
         modifiers?: ("Meta" | "Control" | "Shift" | "Alt" | "default" | undefined)[] | undefined;
         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" | ";" | "=" | "," | "`" | "[" | "\\" | "]", {

package/dist/entities/workspace/workspace.js

@@ -26,7 +26,7 @@ const workspaceSchema = z.object({
     /** List of all collection uids in a given workspace */
     collections: z.array(z.string()).default([]),
     /** List of all environment uids in a given workspace */
-    environments: z.array(z.string()).default([]),
+    environments: z.record(z.string()).default({}),
     /** Customize hotkeys */
     hotKeyConfig: hotKeyConfigSchema,
     /** Active Environment ID to use for requests  */

package/dist/helpers/httpMethods.d.ts

@@ -1,4 +1,4 @@
-import type { RequestMethod } from '../entities/spec/requests.js';
+import { type RequestMethod } from '../entities/spec/requests.js';
 /**
  * HTTP methods in a specific order
  * Do not change the order
@@ -23,5 +23,7 @@ export declare const getHttpMethodInfo: (methodName: string) => {
     color: string;
     backgroundColor: string;
 };
+/** Type guard which takes in a string and returns true if it is in fact an HTTPMethod */
+export declare const isHttpMethod: (method: string) => method is RequestMethod;
 export {};
 //# sourceMappingURL=httpMethods.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"httpMethods.d.ts","sourceRoot":"","sources":["../../src/helpers/httpMethods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE7D;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE;KAC3B,CAAC,IAAI,aAAa,GAAG;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,MAAM,CAAA;QACb,eAAe,EAAE,MAAM,CAAA;KACxB;CA+CO,CAAA;AAEV,yCAAyC;AACzC,QAAA,MAAM,YAAY,6CAA8C,CAAA;AAChE,KAAK,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/C,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,WACpB,aAAa,KACpB,MAAM,IAAI,UAAyD,CAAA;AAEtE;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAgB,MAAM;WAhEzC,MAAM;WACN,MAAM;qBACI,MAAM;CAuE1B,CAAA"}
+{"version":3,"file":"httpMethods.d.ts","sourceRoot":"","sources":["../../src/helpers/httpMethods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,0BAA0B,CAAA;AAE7E;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE;KAC3B,CAAC,IAAI,aAAa,GAAG;QACpB,KAAK,EAAE,MAAM,CAAA;QACb,KAAK,EAAE,MAAM,CAAA;QACb,eAAe,EAAE,MAAM,CAAA;KACxB;CA+CO,CAAA;AAEV,yCAAyC;AACzC,QAAA,MAAM,YAAY,6CAA8C,CAAA;AAChE,KAAK,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;AAE/C,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,WACpB,aAAa,KACpB,MAAM,IAAI,UAAyD,CAAA;AAEtE;;GAEG;AACH,eAAO,MAAM,iBAAiB,eAAgB,MAAM;WAhEzC,MAAM;WACN,MAAM;qBACI,MAAM;CAuE1B,CAAA;AAED,yFAAyF;AACzF,eAAO,MAAM,YAAY,WAAY,MAAM,KAAG,MAAM,IAAI,aACN,CAAA"}

package/dist/helpers/httpMethods.js

@@ -1,3 +1,5 @@
+import { requestMethods } from '../entities/spec/requests.js';
+
 /**
  * HTTP methods in a specific order
  * Do not change the order
@@ -64,5 +66,7 @@ const getHttpMethodInfo = (methodName) => {
         backgroundColor: 'bg-c-2',
     });
 };
+/** Type guard which takes in a string and returns true if it is in fact an HTTPMethod */
+const isHttpMethod = (method) => requestMethods.includes(method);
 
-export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo };
+export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo, isHttpMethod };

package/dist/helpers/index.js

@@ -3,7 +3,7 @@ export { createHash } from './createHash.js';
 export { fetchSpecFromUrl } from './fetchSpecFromUrl.js';
 export { fetchWithProxyFallback } from './fetchWithProxyFallback.js';
 export { findVariables } from './findVariables.js';
-export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo } from './httpMethods.js';
+export { REQUEST_METHODS, canMethodHaveBody, getHttpMethodInfo, isHttpMethod } from './httpMethods.js';
 export { httpStatusCodes } from './httpStatusCodes.js';
 export { isLocalUrl } from './isLocalUrl.js';
 export { isValidUrl } from './isValidUrl.js';

package/dist/migrations/data-version.d.ts

@@ -7,7 +7,7 @@
  * - 2.1.0 - refactor
  * - 2.2.0 - auth compliancy
  */
-export declare const DATA_VERSION = "2.2.0";
+export declare const DATA_VERSION = "2.3.0";
 /** The localStorage key under which the data version is stored */
 export declare const DATA_VERSION_LS_LEY = "scalar_api_client_data_version";
 //# sourceMappingURL=data-version.d.ts.map

package/dist/migrations/data-version.js

@@ -7,7 +7,7 @@
  * - 2.1.0 - refactor
  * - 2.2.0 - auth compliancy
  */
-const DATA_VERSION = '2.2.0';
+const DATA_VERSION = '2.3.0';
 /** The localStorage key under which the data version is stored */
 const DATA_VERSION_LS_LEY = 'scalar_api_client_data_version';
 

package/dist/migrations/migrator.d.ts

@@ -1,4 +1,4 @@
-import { type v_2_2_0 } from '../migrations/v-2.2.0/index.js';
+import { type v_2_3_0 } from '../migrations/v-2.3.0/index.js';
 /** Handles all data migrations per entity */
-export declare const migrator: () => v_2_2_0.DataArray;
+export declare const migrator: () => v_2_3_0.DataArray;
 //# sourceMappingURL=migrator.d.ts.map

package/dist/migrations/migrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../../src/migrations/migrator.ts"],"names":[],"mappings":"AAMA,OAAO,EAAmB,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEpE,6CAA6C;AAC7C,eAAO,MAAM,QAAQ,QAAO,OAAO,CAAC,SAoCnC,CAAA"}
+{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../../src/migrations/migrator.ts"],"names":[],"mappings":"AAOA,OAAO,EAAmB,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEpE,6CAA6C;AAC7C,eAAO,MAAM,QAAQ,QAAO,OAAO,CAAC,SAsCnC,CAAA"}

package/dist/migrations/migrator.js

@@ -2,6 +2,7 @@ import { getLocalStorageVersion, parseLocalStorage } from './local-storage.js';
 import { semverLessThan } from './semver.js';
 import { migrate_v_2_1_0 } from './v-2.1.0/migration.js';
 import { migrate_v_2_2_0 } from './v-2.2.0/migration.js';
+import { migrate_v_2_3_0 } from './v-2.3.0/migration.js';
 
 /** Handles all data migrations per entity */
 const migrator = () => {
@@ -25,6 +26,9 @@ const migrator = () => {
     // 2.1.0 -> 2.2.0 migration
     if (semverLessThan(dataVersion, '2.2.0'))
         data = migrate_v_2_2_0(data);
+    // 2.2.0 -> 2.3.0 migration
+    if (semverLessThan(dataVersion, '2.3.0'))
+        data = migrate_v_2_3_0(data);
     // Convert to data array
     data = {
         collections: Object.values(data.collections),

package/dist/migrations/v-2.2.0/types.generated.d.ts

@@ -1,7 +1,6 @@
 import type { Cookie as Ck } from '../../entities/cookie/index.js';
 import type { Environment as E } from '../../entities/environment/index.js';
 import type { Collection as Co, Request as R, RequestExample as RE, Server as S, SecurityScheme as SS, Tag as T } from '../../entities/spec/index.js';
-import type { Workspace as W } from '../../entities/workspace/index.js';
 /**
  * The most current types are not generated
  */
@@ -14,7 +13,27 @@ export declare namespace v_2_2_0 {
     type SecurityScheme = SS;
     type Server = S;
     type Tag = T;
-    type Workspace = W;
+    type Workspace = {
+        uid: string;
+        name: string;
+        description: string;
+        isReadOnly: boolean;
+        collections: string[];
+        environments: string[];
+        hotKeyConfig?: {
+            modifiers: ('Meta' | 'Control' | 'Shift' | 'Alt' | 'default')[];
+            hotKeys?: {
+                [x: string]: {
+                    modifiers?: ('Meta' | 'Control' | 'Shift' | 'Alt' | 'default')[] | undefined;
+                    event: 'closeModal' | 'navigateSearchResultsDown' | 'selectSearchResult' | 'navigateSearchResultsUp' | 'openCommandPalette' | 'createNew' | 'toggleSidebar' | 'addTopNav' | 'closeTopNav' | 'navigateTopNavLeft' | 'navigateTopNavRight' | 'focusAddressBar' | 'jumpToTab' | 'jumpToLastTab' | 'focusRequestSearch';
+                };
+            } | undefined;
+        } | undefined;
+        activeEnvironmentId: string;
+        cookies: string[];
+        proxyUrl?: string | undefined;
+        themeId: 'alternate' | 'default' | 'moon' | 'purple' | 'solarized' | 'bluePlanet' | 'deepSpace' | 'saturn' | 'kepler' | 'mars' | 'none';
+    };
     type DataRecord = {
         collections: Record<string, Collection>;
         cookies: Record<string, Cookie>;

package/dist/migrations/v-2.2.0/types.generated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.generated.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.2.0/types.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,IAAI,CAAC,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,KAAK,EACV,UAAU,IAAI,EAAE,EAChB,OAAO,IAAI,CAAC,EACZ,cAAc,IAAI,EAAE,EACpB,MAAM,IAAI,CAAC,EACX,cAAc,IAAI,EAAE,EACpB,GAAG,IAAI,CAAC,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,SAAS,IAAI,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAE1D;;GAEG;AACH,yBAAiB,OAAO,CAAC;IACvB,KAAY,MAAM,GAAG,EAAE,CAAA;IACvB,KAAY,WAAW,GAAG,CAAC,CAAA;IAC3B,KAAY,UAAU,GAAG,EAAE,CAAA;IAC3B,KAAY,OAAO,GAAG,CAAC,CAAA;IACvB,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,MAAM,GAAG,CAAC,CAAA;IACtB,KAAY,GAAG,GAAG,CAAC,CAAA;IACnB,KAAY,SAAS,GAAG,CAAC,CAAA;IAEzB,KAAY,UAAU,GAAG;QACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;QACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;QACzC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;KACtC,CAAA;IAED,KAAY,SAAS,GAAG;QACtB,WAAW,EAAE,UAAU,EAAE,CAAA;QACzB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,YAAY,EAAE,WAAW,EAAE,CAAA;QAC3B,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,QAAQ,EAAE,OAAO,EAAE,CAAA;QACnB,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,IAAI,EAAE,GAAG,EAAE,CAAA;QACX,UAAU,EAAE,SAAS,EAAE,CAAA;KACxB,CAAA;CACF"}
+{"version":3,"file":"types.generated.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.2.0/types.generated.ts"],"names":[],"mappings":"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"}

package/dist/migrations/v-2.3.0/index.d.ts

@@ -0,0 +1,3 @@
+export * from './migration.js';
+export * from './types.generated';
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/v-2.3.0/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.3.0/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA"}

package/dist/migrations/v-2.3.0/index.js

@@ -0,0 +1 @@
+export { migrate_v_2_3_0 } from './migration.js';

package/dist/migrations/v-2.3.0/migration.d.ts

@@ -0,0 +1,5 @@
+import type { v_2_2_0 } from '../../migrations/v-2.2.0/types.generated';
+import type { v_2_3_0 } from './types.generated';
+/** V-2.2.0 to V-2.3.0 migration */
+export declare const migrate_v_2_3_0: (data: v_2_2_0.DataRecord) => v_2_3_0.DataRecord;
+//# sourceMappingURL=migration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.3.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"}

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

@@ -0,0 +1,55 @@
+/** V-2.2.0 to V-2.3.0 migration */
+const migrate_v_2_3_0 = (data) => {
+    console.info('Performing data migration v-2.2.0 to v-2.3.0');
+    const environments = data.environments;
+    const workspaces = Object.values(data.workspaces).reduce((prev, w) => {
+        const workspaceEnvironments = {};
+        Object.entries(environments).forEach(([envId, envData]) => {
+            const parsedData = typeof envData.value === 'string'
+                ? JSON.parse(envData.value)
+                : envData.value;
+            if (envId === 'default') {
+                Object.assign(workspaceEnvironments, parsedData);
+            }
+        });
+        prev[w.uid] = {
+            ...w,
+            environments: workspaceEnvironments,
+        };
+        return prev;
+    }, {});
+    const collections = Object.values(data.collections).reduce((prev, c) => {
+        prev[c.uid] = {
+            ...c,
+            'x-scalar-environments': c['x-scalar-environments'] || {},
+        };
+        return prev;
+    }, {});
+    Object.values(workspaces).forEach((workspace) => {
+        Object.entries(environments).forEach(([envKey, envData]) => {
+            if (envKey !== 'default') {
+                const parsedData = typeof envData.value === 'string'
+                    ? JSON.parse(envData.value)
+                    : envData.value;
+                const envName = envData.name;
+                Object.values(collections).forEach((collection) => {
+                    collection['x-scalar-environments'] =
+                        collection['x-scalar-environments'] || {};
+                    collection['x-scalar-environments'][envName] = {
+                        variables: parsedData,
+                    };
+                    if (workspace.activeEnvironmentId === envKey) {
+                        collection['x-scalar-active-environment'] = envName ?? '';
+                    }
+                });
+            }
+        });
+    });
+    return {
+        ...data,
+        collections,
+        workspaces,
+    };
+};
+
+export { migrate_v_2_3_0 };

package/dist/migrations/v-2.3.0/types.generated.d.ts

@@ -0,0 +1,38 @@
+import type { Cookie as Ck } from '../../entities/cookie/index.js';
+import type { Environment as E } from '../../entities/environment/index.js';
+import type { Collection as Co, Request as R, RequestExample as RE, Server as S, SecurityScheme as SS, Tag as T } from '../../entities/spec/index.js';
+import type { Workspace as W } from '../../entities/workspace/index.js';
+export declare namespace v_2_3_0 {
+    type Cookie = Ck;
+    type Environment = E;
+    type Collection = Co;
+    type Request = R;
+    type RequestExample = RE;
+    type SecurityScheme = SS;
+    type Server = S;
+    type Tag = T;
+    type Workspace = W;
+    type DataRecord = {
+        collections: Record<string, Collection>;
+        cookies: Record<string, Cookie>;
+        environments: Record<string, Environment>;
+        requestExamples: Record<string, RequestExample>;
+        requests: Record<string, Request>;
+        securitySchemes: Record<string, SecurityScheme>;
+        servers: Record<string, Server>;
+        tags: Record<string, Tag>;
+        workspaces: Record<string, Workspace>;
+    };
+    type DataArray = {
+        collections: Collection[];
+        cookies: Cookie[];
+        environments: Environment[];
+        requestExamples: RequestExample[];
+        requests: Request[];
+        securitySchemes: SecurityScheme[];
+        servers: Server[];
+        tags: Tag[];
+        workspaces: Workspace[];
+    };
+}
+//# sourceMappingURL=types.generated.d.ts.map

package/dist/migrations/v-2.3.0/types.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.generated.d.ts","sourceRoot":"","sources":["../../../src/migrations/v-2.3.0/types.generated.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,IAAI,CAAC,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,KAAK,EACV,UAAU,IAAI,EAAE,EAChB,OAAO,IAAI,CAAC,EACZ,cAAc,IAAI,EAAE,EACpB,MAAM,IAAI,CAAC,EACX,cAAc,IAAI,EAAE,EACpB,GAAG,IAAI,CAAC,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,SAAS,IAAI,CAAC,EAAE,MAAM,sBAAsB,CAAA;AAE1D,yBAAiB,OAAO,CAAC;IACvB,KAAY,MAAM,GAAG,EAAE,CAAA;IACvB,KAAY,WAAW,GAAG,CAAC,CAAA;IAC3B,KAAY,UAAU,GAAG,EAAE,CAAA;IAC3B,KAAY,OAAO,GAAG,CAAC,CAAA;IACvB,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,cAAc,GAAG,EAAE,CAAA;IAC/B,KAAY,MAAM,GAAG,CAAC,CAAA;IACtB,KAAY,GAAG,GAAG,CAAC,CAAA;IACnB,KAAY,SAAS,GAAG,CAAC,CAAA;IAEzB,KAAY,UAAU,GAAG;QACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;QACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;QACzC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC/C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;KACtC,CAAA;IAED,KAAY,SAAS,GAAG;QACtB,WAAW,EAAE,UAAU,EAAE,CAAA;QACzB,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,YAAY,EAAE,WAAW,EAAE,CAAA;QAC3B,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,QAAQ,EAAE,OAAO,EAAE,CAAA;QACnB,eAAe,EAAE,cAAc,EAAE,CAAA;QACjC,OAAO,EAAE,MAAM,EAAE,CAAA;QACjB,IAAI,EAAE,GAAG,EAAE,CAAA;QACX,UAAU,EAAE,SAAS,EAAE,CAAA;KACxB,CAAA;CACF"}

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

@@ -1,6 +1,5 @@
 export * from './getExampleFromSchema.js';
 export * from './getParametersFromOperation.js';
 export * from './getRequestBodyFromOperation.js';
-export * from './getRequestFromOperation.js';
 export * from './getServerVariableExamples.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spec-getters/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spec-getters/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAA;AACtC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,6BAA6B,CAAA"}

package/dist/spec-getters/index.js

@@ -1,5 +1,4 @@
 export { getExampleFromSchema } from './getExampleFromSchema.js';
 export { getParametersFromOperation } from './getParametersFromOperation.js';
 export { getRequestBodyFromOperation } from './getRequestBodyFromOperation.js';
-export { getRequestFromOperation } from './getRequestFromOperation.js';
 export { getServerVariableExamples } from './getServerVariableExamples.js';

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

@@ -4,20 +4,21 @@ import type { OpenAPIV3, OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { ReferenceConfiguration } from '@scalar/types/legacy';
 import type { UnknownObject } from '@scalar/types/utils';
 /** Takes a string or object and parses it into an openapi spec compliant schema */
-export declare const parseSchema: (spec: string | UnknownObject) => Promise<{
+export declare const parseSchema: (spec: string | UnknownObject, { shouldLoad }?: {
+    shouldLoad?: boolean | undefined;
+}) => Promise<{
     /**
      * Temporary fix for the parser returning an empty array
      * TODO: remove this once the parser is fixed
      */
     schema: OpenAPIV3.Document | OpenAPIV3_1.Document;
-    errors: ({
-        code: any;
-        message: any;
-    } | import("@scalar/openapi-parser").ErrorObject)[];
+    errors: import("@scalar/openapi-parser").ErrorObject[];
 }>;
 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;
+    /** Call the load step from the parser */
+    shouldLoad?: boolean;
 };
 /**
  * Imports an OpenAPI document and converts it to workspace entities (Collection, Request, Server, etc.)
@@ -32,7 +33,7 @@ export type ImportSpecToWorkspaceArgs = Pick<CollectionPayload, 'documentUrl' |
  * - Proper linking between related components
  * - Easy lookup and reference of dependent entities
  */
-export declare function importSpecToWorkspace(spec: string | UnknownObject, { authentication, baseServerURL, documentUrl, servers: overloadServers, setCollectionSecurity, watchMode, }?: ImportSpecToWorkspaceArgs): Promise<{
+export declare function importSpecToWorkspace(spec: string | UnknownObject, { authentication, baseServerURL, documentUrl, servers: overloadServers, setCollectionSecurity, shouldLoad, watchMode, }?: ImportSpecToWorkspaceArgs): Promise<{
     error: false;
     collection: Collection;
     requests: Request[];

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,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,EACZ,KAAK,cAAc,EAGnB,KAAK,MAAM,EACX,KAAK,GAAG,EAOT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,0BAA0B,CAAA;AAIjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGxD,mFAAmF;AACnF,eAAO,MAAM,WAAW,SAAgB,MAAM,GAAG,aAAa;IAwB1D;;;OAGG;YAEC,SAAS,CAAC,QAAQ,GAClB,WAAW,CAAC,QAAQ;;;;;EAG3B,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;CAChC,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,EACE,cAAc,EACd,aAAa,EACb,WAAW,EACX,OAAO,EAAE,eAAe,EACxB,qBAA6B,EAC7B,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,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;IACjD,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,CAuVA"}
+{"version":3,"file":"import-spec.d.ts","sourceRoot":"","sources":["../../src/transforms/import-spec.ts"],"names":[],"mappings":"AAAA,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;AAUjC,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnE,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;;;IA+B1B;;;OAGG;YAEC,SAAS,CAAC,QAAQ,GAClB,WAAW,CAAC,QAAQ;;EAG3B,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,eAAe,EACxB,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,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAA;IACjD,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,CAsVA"}

package/dist/transforms/import-spec.js

@@ -1,26 +1,33 @@
 import { securitySchemeSchema } from '../entities/spec/security.js';
+import { isHttpMethod } from '../helpers/httpMethods.js';
 import { schemaModel } from '../helpers/schema-model.js';
 import { keysOf } from '@scalar/object-utils/arrays';
 import { load, upgrade, dereference } from '@scalar/openapi-parser';
 import { serverSchema } from '../entities/spec/server.js';
-import { requestMethods, requestSchema } from '../entities/spec/requests.js';
+import { requestSchema } from '../entities/spec/requests.js';
 import { tagSchema } from '../entities/spec/spec-objects.js';
 import { createExampleFromRequest } from '../entities/spec/request-examples.js';
 import { collectionSchema } from '../entities/spec/collection.js';
 
 /** Takes a string or object and parses it into an openapi spec compliant schema */
-const parseSchema = async (spec) => {
+const parseSchema = async (spec, { shouldLoad = true } = {}) => {
     // TODO: Plugins for URLs and files with the proxy is missing here.
     // @see packages/api-reference/src/helpers/parse.ts
-    const { filesystem, errors: loadErrors = [] } = await load(spec).catch((e) => ({
-        errors: [
-            {
-                code: e.code,
-                message: e.message,
-            },
-        ],
-        filesystem: [],
-    }));
+    let filesystem = spec;
+    let loadErrors = [];
+    if (shouldLoad) {
+        const resp = await load(spec).catch((e) => ({
+            errors: [
+                {
+                    code: e.code,
+                    message: e.message,
+                },
+            ],
+            filesystem: [],
+        }));
+        filesystem = resp.filesystem;
+        loadErrors = resp.errors ?? [];
+    }
     const { specification } = upgrade(filesystem);
     const { schema, errors: derefErrors = [] } = await dereference(specification);
     if (!schema)
@@ -47,8 +54,8 @@ const parseSchema = async (spec) => {
  * - Proper linking between related components
  * - Easy lookup and reference of dependent entities
  */
-async function importSpecToWorkspace(spec, { authentication, baseServerURL, documentUrl, servers: overloadServers, setCollectionSecurity = false, watchMode = false, } = {}) {
-    const { schema, errors } = await parseSchema(spec);
+async function importSpecToWorkspace(spec, { authentication, baseServerURL, documentUrl, servers: overloadServers, setCollectionSecurity = false, shouldLoad, watchMode = false, } = {}) {
+    const { schema, errors } = await parseSchema(spec, { shouldLoad });
     const importWarnings = [...errors.map((e) => e.message)];
     if (!schema)
         return { importWarnings, error: true };
@@ -161,77 +168,77 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
         // Path level servers must be saved
         const pathServers = serverSchema.array().parse(path.servers ?? []);
         servers.push(...pathServers);
-        requestMethods.forEach((method) => {
+        // Creates a sorted array of methods based on the path object.
+        const methods = Object.keys(path).filter(isHttpMethod);
+        methods.forEach((method) => {
             const operation = path[method];
-            if (operation && typeof operation === 'object') {
-                const operationServers = serverSchema
-                    .array()
-                    .parse(operation.servers ?? []);
-                servers.push(...operationServers);
-                // We will save a list of all tags to ensure they exists at the top level
-                // TODO: make sure we add any loose requests with no tags to the collection children
-                operation.tags?.forEach((t) => tagNames.add(t));
-                // Remove security here and add it correctly below
-                const { security: operationSecurity, ...operationWithoutSecurity } = operation;
-                // Grab the security requirements for this operation
-                const securityRequirements = (operationSecurity ??
-                    schema.security ??
-                    []).flatMap((s) => {
+            const operationServers = serverSchema
+                .array()
+                .parse(operation.servers ?? []);
+            servers.push(...operationServers);
+            // We will save a list of all tags to ensure they exists at the top level
+            // TODO: make sure we add any loose requests with no tags to the collection children
+            operation.tags?.forEach((t) => tagNames.add(t));
+            // Remove security here and add it correctly below
+            const { security: operationSecurity, ...operationWithoutSecurity } = operation;
+            // Grab the security requirements for this operation
+            const securityRequirements = (operationSecurity ??
+                schema.security ??
+                []).flatMap((s) => {
+                const keys = Object.keys(s);
+                if (keys.length)
+                    return keys[0];
+                else
+                    return [];
+            });
+            let selectedSecuritySchemeUids = [];
+            // Set the initially selected security scheme
+            if (securityRequirements.length && !setCollectionSecurity) {
+                const name = authentication?.preferredSecurityScheme &&
+                    securityRequirements.includes(authentication.preferredSecurityScheme ?? '')
+                    ? authentication.preferredSecurityScheme
+                    : securityRequirements[0];
+                const uid = securitySchemeMap[name];
+                selectedSecuritySchemeUids = [uid];
+            }
+            const requestPayload = {
+                ...operationWithoutSecurity,
+                method,
+                path: pathString,
+                selectedSecuritySchemeUids,
+                // Merge path and operation level parameters
+                parameters: [
+                    ...(path?.parameters ?? []),
+                    ...(operation.parameters ?? []),
+                ],
+                servers: [...pathServers, ...operationServers].map((s) => s.uid),
+            };
+            // Remove any examples from the request payload as they conflict with our examples property and are not valid
+            if (requestPayload.examples) {
+                console.warn('[@scalar/api-client] operation.examples is not a valid openapi property');
+                delete requestPayload.examples;
+            }
+            // Add list of UIDs to associate security schemes
+            // As per the spec if there is operation level security we ignore the top level requirements
+            if (operationSecurity?.length)
+                requestPayload.security = operationSecurity.map((s) => {
                     const keys = Object.keys(s);
-                    if (keys.length)
-                        return keys[0];
+                    // Handle the case of {} for optional
+                    if (keys.length) {
+                        const [key] = Object.keys(s);
+                        return {
+                            [key]: s[key],
+                        };
+                    }
                     else
-                        return [];
+                        return s;
                 });
-                let selectedSecuritySchemeUids = [];
-                // Set the initially selected security scheme
-                if (securityRequirements.length && !setCollectionSecurity) {
-                    const name = authentication?.preferredSecurityScheme &&
-                        securityRequirements.includes(authentication.preferredSecurityScheme ?? '')
-                        ? authentication.preferredSecurityScheme
-                        : securityRequirements[0];
-                    const uid = securitySchemeMap[name];
-                    selectedSecuritySchemeUids = [uid];
-                }
-                const requestPayload = {
-                    ...operationWithoutSecurity,
-                    method,
-                    path: pathString,
-                    selectedSecuritySchemeUids,
-                    // Merge path and operation level parameters
-                    parameters: [
-                        ...(path?.parameters ?? []),
-                        ...(operation.parameters ?? []),
-                    ],
-                    servers: [...pathServers, ...operationServers].map((s) => s.uid),
-                };
-                // Remove any examples from the request payload as they conflict with our examples property and are not valid
-                if (requestPayload.examples) {
-                    console.warn('[@scalar/api-client] operation.examples is not a valid openapi property');
-                    delete requestPayload.examples;
-                }
-                // Add list of UIDs to associate security schemes
-                // As per the spec if there is operation level security we ignore the top level requirements
-                if (operationSecurity?.length)
-                    requestPayload.security = operationSecurity.map((s) => {
-                        const keys = Object.keys(s);
-                        // Handle the case of {} for optional
-                        if (keys.length) {
-                            const [key] = Object.keys(s);
-                            return {
-                                [key]: s[key],
-                            };
-                        }
-                        else
-                            return s;
-                    });
-                // Save parse the request
-                const request = schemaModel(requestPayload, requestSchema, false);
-                if (!request)
-                    importWarnings.push(`${method} Request at ${path} is invalid.`);
-                else
-                    requests.push(request);
-            }
+            // Save parse the request
+            const request = schemaModel(requestPayload, requestSchema, false);
+            if (!request)
+                importWarnings.push(`${method} Request at ${path} is invalid.`);
+            else
+                requests.push(request);
         });
     });
     // ---------------------------------------------------------------------------
@@ -283,7 +290,7 @@ async function importSpecToWorkspace(spec, { authentication, baseServerURL, docu
     });
     // ---------------------------------------------------------------------------
     // Generate Collection
-    const securityKeys = Object.keys(security);
+    const securityKeys = Object.keys(schema.security?.[0] ?? security ?? {});
     let selectedSecuritySchemeUids = [];
     /** Selected security scheme UIDs for the collection, defaults to the first key */
     if (setCollectionSecurity && securityKeys.length) {

package/package.json

@@ -16,7 +16,7 @@
     "specification",
     "yaml"
   ],
-  "version": "0.2.84",
+  "version": "0.2.86",
   "engines": {
     "node": ">=18"
   },
@@ -38,6 +38,11 @@
       "types": "./dist/migrations/index.d.ts",
       "default": "./dist/migrations/index.js"
     },
+    "./migrations/v-2.3.0": {
+      "import": "./dist/migrations/v-2.3.0/index.js",
+      "types": "./dist/migrations/v-2.3.0/index.d.ts",
+      "default": "./dist/migrations/v-2.3.0/index.js"
+    },
     "./migrations/v-2.2.0": {
       "import": "./dist/migrations/v-2.2.0/index.js",
       "types": "./dist/migrations/v-2.2.0/index.d.ts",
@@ -112,8 +117,8 @@
     "yaml": "^2.4.5",
     "zod": "^3.23.8",
     "@scalar/object-utils": "1.1.12",
-    "@scalar/themes": "0.9.54",
     "@scalar/openapi-types": "0.1.5",
+    "@scalar/themes": "0.9.54",
     "@scalar/types": "0.0.23"
   },
   "devDependencies": {

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

@@ -1,10 +0,0 @@
-import type { HarRequestWithPath, TransformedOperation } from '@scalar/types/legacy';
-export declare const getRequestFromOperation: (operation: TransformedOperation, options?: {
-    /**
-     * If the path will be URL encoded, you may want to replace {curlyBrackets} with __UNDERSCORES__ to indicate an
-     * variable.
-     */
-    replaceVariables?: boolean;
-    requiredOnly?: boolean;
-}, selectedExampleKey?: string | number, omitEmptyAndOptionalProperties?: boolean) => Partial<HarRequestWithPath>;
-//# sourceMappingURL=getRequestFromOperation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getRequestFromOperation.d.ts","sourceRoot":"","sources":["../../src/spec-getters/getRequestFromOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAGlB,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAM7B,eAAO,MAAM,uBAAuB,cACvB,oBAAoB,YACrB;IACR;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,uBACoB,MAAM,GAAG,MAAM,mCACH,OAAO,KACvC,OAAO,CAAC,kBAAkB,CAgE5B,CAAA"}

package/dist/spec-getters/getRequestFromOperation.js

@@ -1,48 +0,0 @@
-import { getParametersFromOperation } from './getParametersFromOperation.js';
-import { getRequestBodyFromOperation } from './getRequestBodyFromOperation.js';
-import { REGEX } from '../helpers/regexHelpers.js';
-
-const getRequestFromOperation = (operation, options, selectedExampleKey, omitEmptyAndOptionalProperties) => {
-    // Replace all variables of the format {something} with the uppercase variable name without the brackets
-    let path = operation.path;
-    // {id} -> 123
-    const pathParameters = getParametersFromOperation(operation, 'path', false);
-    if (pathParameters.length) {
-        const pathVariables = path.match(REGEX.PATH);
-        if (pathVariables) {
-            pathVariables.forEach((variable) => {
-                const variableName = variable.replace(/{|}/g, '');
-                if (pathParameters) {
-                    const parameter = pathParameters.find((param) => param.name === variableName);
-                    if (parameter?.value) {
-                        path = path.replace(variable, parameter.value.toString());
-                    }
-                }
-            });
-        }
-    }
-    // {id} -> __ID__
-    if (options?.replaceVariables === true) {
-        const pathVariables = path.match(REGEX.PATH);
-        if (pathVariables) {
-            pathVariables.forEach((variable) => {
-                const variableName = variable.replace(/{|}/g, '');
-                path = path.replace(variable, `__${variableName.toUpperCase()}__`);
-            });
-        }
-    }
-    const requestBody = getRequestBodyFromOperation(operation, selectedExampleKey, omitEmptyAndOptionalProperties);
-    return {
-        method: operation.httpVerb.toUpperCase(),
-        path,
-        postData: requestBody?.body,
-        headers: [
-            ...getParametersFromOperation(operation, 'header', options?.requiredOnly),
-            ...(requestBody?.headers ?? []),
-        ],
-        queryString: getParametersFromOperation(operation, 'query', options?.requiredOnly),
-        cookies: getParametersFromOperation(operation, 'cookie', options?.requiredOnly),
-    };
-};
-
-export { getRequestFromOperation };