@scalar/workspace-store 0.42.0 → 0.43.1

package/dist/request-example/context/security/merge-security.js

@@ -0,0 +1,29 @@
+import { objectEntries } from '@scalar/helpers/object/object-entries';
+import { deepClone } from '@scalar/workspace-store/helpers/deep-clone';
+import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
+import { mergeObjects } from '@scalar/workspace-store/helpers/merge-object';
+import { coerceValue } from '@scalar/workspace-store/schemas/typebox-coerce';
+import { SecuritySchemeObjectSchema, } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import { extractSecuritySchemeSecrets } from './extract-security-scheme-secrets.js';
+/** Merge the authentication config with the document security schemes + the auth store secrets */
+export const mergeSecurity = (documentSecuritySchemes = {}, configSecuritySchemes = {}, authStore, documentName) => {
+    /** Resolve any refs in the document security schemes */
+    const resolvedDocumentSecuritySchemes = objectEntries(documentSecuritySchemes).reduce((acc, [key, value]) => {
+        const resolved = deepClone(getResolvedRef(value));
+        if (resolved) {
+            acc[key] = resolved;
+        }
+        return acc;
+    }, {});
+    /** Merge the config security schemes into the document security schemes */
+    const mergedSchemes = mergeObjects(resolvedDocumentSecuritySchemes, configSecuritySchemes) ?? {};
+    /** Convert the config secrets to the new secret extensions */
+    return objectEntries(mergedSchemes).reduce((acc, [name, value]) => {
+        // We coerce in case the scheme is missing any key fields like type
+        const coerced = coerceValue(SecuritySchemeObjectSchema, value);
+        // We then overwrite it back with the original value to keep any other fields like description, etc.
+        const merged = { ...coerced, ...value };
+        acc[name] = extractSecuritySchemeSecrets(merged, authStore, name, documentName);
+        return acc;
+    }, {});
+};

package/dist/request-example/context/servers.d.ts

@@ -0,0 +1,26 @@
+import type { ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
+import type { WorkspaceDocument } from '../../schemas.js';
+import type { OperationObject } from '../../schemas/v3.1/strict/operation.js';
+/**
+ * Server processing options containing base URLs for resolving relative server URLs.
+ */
+type ServerProcessingOptions = {
+    baseServerUrl?: string;
+    documentUrl?: string;
+};
+/**
+ * Retrieves and processes servers from an OpenAPI document.
+ *
+ * This function handles several scenarios:
+ * 1. No servers provided - creates a default server from document URL or fallback
+ * 2. Invalid server configurations - filters them out with warnings
+ * 3. Relative URLs - resolves them to absolute URLs using available base URLs
+ *
+ * @param servers - Array of OpenAPI server objects from the document
+ * @param options - Configuration options for server processing
+ * @returns Array of validated Server entities
+ */
+export declare function getServers(servers: ServerObject[] | undefined, options?: ServerProcessingOptions): ServerObject[];
+export declare const getSelectedServer: (document: WorkspaceDocument | null, operation: OperationObject | null, configServers: ServerObject[] | null, servers: ServerObject[]) => ServerObject | null;
+export {};
+//# sourceMappingURL=servers.d.ts.map

package/dist/request-example/context/servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"servers.d.ts","sourceRoot":"","sources":["../../../src/request-example/context/servers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8DAA8D,CAAA;AAEhG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE;;GAEG;AACH,KAAK,uBAAuB,GAAG;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,SAAS,EAAE,OAAO,GAAE,uBAA4B,GAAG,YAAY,EAAE,CASrH;AAoED,eAAO,MAAM,iBAAiB,GAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,eAAe,GAAG,IAAI,EACjC,eAAe,YAAY,EAAE,GAAG,IAAI,EACpC,SAAS,YAAY,EAAE,KACtB,YAAY,GAAG,IAWjB,CAAA"}

package/dist/request-example/context/servers.js

@@ -0,0 +1,89 @@
+import { combineUrlAndPath } from '@scalar/helpers/url/merge-urls';
+/**
+ * Retrieves and processes servers from an OpenAPI document.
+ *
+ * This function handles several scenarios:
+ * 1. No servers provided - creates a default server from document URL or fallback
+ * 2. Invalid server configurations - filters them out with warnings
+ * 3. Relative URLs - resolves them to absolute URLs using available base URLs
+ *
+ * @param servers - Array of OpenAPI server objects from the document
+ * @param options - Configuration options for server processing
+ * @returns Array of validated Server entities
+ */
+export function getServers(servers, options = {}) {
+    // Handle invalid server array
+    if (!Array.isArray(servers)) {
+        return [];
+    }
+    // Process each server and filter out invalid ones
+    const validServers = servers.map((server) => processServerObject(server, options));
+    return validServers;
+}
+/**
+ * Extracts the base URL (protocol + hostname) from a document URL.
+ * Returns undefined if the URL is invalid.
+ */
+function extractBaseUrlFromDocumentUrl(documentUrl) {
+    try {
+        const url = new URL(documentUrl);
+        const port = url.port ? `:${url.port}` : '';
+        return `${url.protocol}//${url.hostname}${port}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Gets the fallback URL from window.location.origin if available.
+ */
+function getFallbackUrl() {
+    if (typeof window === 'undefined' || typeof window?.location?.origin !== 'string') {
+        return undefined;
+    }
+    return window.location.origin;
+}
+/**
+ * Resolves a relative server URL to an absolute URL using available base URLs.
+ * Uses a priority system: baseServerURL > documentUrl > fallbackUrl.
+ */
+function resolveRelativeServerUrl(serverUrl, options) {
+    const { baseServerUrl: baseServerURL, documentUrl } = options;
+    // Priority 1: Use provided base server URL
+    if (baseServerURL) {
+        return combineUrlAndPath(baseServerURL, serverUrl);
+    }
+    // Priority 2: Extract base URL from document URL
+    if (documentUrl) {
+        const baseUrl = extractBaseUrlFromDocumentUrl(documentUrl);
+        if (baseUrl) {
+            return combineUrlAndPath(baseUrl, serverUrl);
+        }
+    }
+    // Priority 3: Use fallback URL (window.location.origin)
+    const fallbackUrl = getFallbackUrl();
+    if (fallbackUrl) {
+        return combineUrlAndPath(fallbackUrl, serverUrl);
+    }
+    // If no base URL is available, return the original URL
+    return serverUrl;
+}
+/**
+ * Processes a single server object, handling validation and URL resolution.
+ */
+function processServerObject(server, options) {
+    // Resolve relative URLs to absolute URLs
+    if (server.url?.startsWith('/')) {
+        server.url = resolveRelativeServerUrl(server.url, options);
+    }
+    return server;
+}
+export const getSelectedServer = (document, operation, configServers, servers) => {
+    const selectedServerUrl = configServers != null
+        ? document?.['x-scalar-selected-server']
+        : (operation?.['x-scalar-selected-server'] ?? document?.['x-scalar-selected-server']);
+    if (selectedServerUrl == null) {
+        return servers[0] ?? null;
+    }
+    return servers.find(({ url }) => url === selectedServerUrl) ?? null;
+};

package/dist/request-example/index.d.ts

@@ -0,0 +1,5 @@
+export { buildRequest, buildRequestSecurity, deSerializeParameter, filterGlobalCookie, getEnvironmentVariables, getExample, getExampleFromBody, getExampleFromSchema, getResolvedUrl, getSelectedBodyContentType, getServerVariables, requestFactory, serializeContentValue, serializeDeepObjectStyle, serializeFormStyle, serializeFormStyleForCookies, serializePipeDelimitedStyle, serializeSimpleStyle, serializeSpaceDelimitedStyle, } from './builder/index.js';
+export type { ApiKeyObjectSecret, HttpObjectSecret, OAuth2ObjectSecret, OAuthFlowAuthorizationCodeSecret, OAuthFlowClientCredentialsSecret, OAuthFlowImplicitSecret, OAuthFlowPasswordSecret, OAuthFlowsObjectSecret, OpenIdConnectObjectSecret, SecuritySchemeObjectSecret, } from './builder/index.js';
+export { combineParams, getActiveEnvironment, getActiveProxyUrl, getRequestExampleContext, getSecurityRequirements, getSecuritySchemes, getSelectedSecurity, getSelectedServer, getServers, isAuthOptional, mergeSecurity, } from './context/index.js';
+export type { MergedSecuritySchemes } from './context/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/request-example/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/request-example/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,0BAA0B,EAC1B,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EAClB,4BAA4B,EAC5B,2BAA2B,EAC3B,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,gCAAgC,EAChC,gCAAgC,EAChC,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EACxB,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,UAAU,EACV,cAAc,EACd,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA"}

package/dist/request-example/index.js

@@ -0,0 +1,2 @@
+export { buildRequest, buildRequestSecurity, deSerializeParameter, filterGlobalCookie, getEnvironmentVariables, getExample, getExampleFromBody, getExampleFromSchema, getResolvedUrl, getSelectedBodyContentType, getServerVariables, requestFactory, serializeContentValue, serializeDeepObjectStyle, serializeFormStyle, serializeFormStyleForCookies, serializePipeDelimitedStyle, serializeSimpleStyle, serializeSpaceDelimitedStyle, } from './builder/index.js';
+export { combineParams, getActiveEnvironment, getActiveProxyUrl, getRequestExampleContext, getSecurityRequirements, getSecuritySchemes, getSelectedSecurity, getSelectedServer, getServers, isAuthOptional, mergeSecurity, } from './context/index.js';

package/dist/request-example/types.d.ts

@@ -0,0 +1,14 @@
+import type { HttpMethod } from '@scalar/helpers/http/http-methods';
+export type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+};
+export type RequestExampleMeta = {
+    path: string;
+    method: HttpMethod;
+    exampleName: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/request-example/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/request-example/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAEnE,MAAM,MAAM,MAAM,CAAC,CAAC,IAChB;IACE,EAAE,EAAE,IAAI,CAAA;IACR,IAAI,EAAE,CAAC,CAAA;CACR,GACD;IACE,EAAE,EAAE,KAAK,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAEL,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA"}

package/dist/request-example/types.js

@@ -0,0 +1 @@
+export {};

package/dist/schemas/extensions/operation/index.d.ts

@@ -1,5 +1,6 @@
 export { type XBadge, XBadgeSchema, type XBadges, XBadgesSchema, } from './x-badge.js';
-export { type XCodeSample, XCodeSamplesSchema, } from './x-code-samples.js';
+export { type XCodeSample, type XCodeSamples, XCodeSamplesSchema, } from './x-code-samples.js';
+export { type XPostResponse, XPostResponseSchema, } from './x-post-response.js';
 export { type XScalarSelectedContentType, XScalarSelectedContentTypeSchema, } from './x-scalar-selected-content-type.js';
 export { XScalarStabilitySchema, XScalarStabilityValues, } from './x-scalar-stability.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/extensions/operation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,YAAY,EACZ,KAAK,OAAO,EACZ,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,KAAK,WAAW,EAChB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,0BAA0B,EAC/B,gCAAgC,GACjC,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACL,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/operation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,YAAY,EACZ,KAAK,OAAO,EACZ,aAAa,GACd,MAAM,WAAW,CAAA;AAClB,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,aAAa,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,KAAK,0BAA0B,EAC/B,gCAAgC,GACjC,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACL,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sBAAsB,CAAA"}

package/dist/schemas/extensions/operation/index.js

@@ -1,4 +1,5 @@
 export { XBadgeSchema, XBadgesSchema, } from './x-badge.js';
 export { XCodeSamplesSchema, } from './x-code-samples.js';
+export { XPostResponseSchema, } from './x-post-response.js';
 export { XScalarSelectedContentTypeSchema, } from './x-scalar-selected-content-type.js';
 export { XScalarStabilitySchema, XScalarStabilityValues, } from './x-scalar-stability.js';

package/dist/schemas/extensions/tag/x-tag-groups.d.ts

@@ -9,12 +9,12 @@ export type XTagGroup = {
      */
     tags: string[];
 } & XScalarOrder;
-export declare const XTagGroup: import("@scalar/validation").IntersectionSchema<(import("@scalar/validation").ObjectSchema<{
-    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
-}> | import("@scalar/validation").ObjectSchema<{
+export declare const XTagGroup: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
     name: import("@scalar/validation").StringSchema;
     tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
-}>)[]>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>]>;
 /**
  * x-tagGroups
  *
@@ -43,11 +43,11 @@ export type XTagGroups = {
     'x-tagGroups'?: XTagGroup[];
 };
 export declare const XTagGroups: import("@scalar/validation").ObjectSchema<{
-    'x-tagGroups': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<(import("@scalar/validation").ObjectSchema<{
-        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
-    }> | import("@scalar/validation").ObjectSchema<{
+    'x-tagGroups': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
         name: import("@scalar/validation").StringSchema;
         tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
-    }>)[]>>>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>]>>>;
 }>;
 //# sourceMappingURL=x-tag-groups.d.ts.map

package/dist/schemas/extensions/tag/x-tag-groups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"x-tag-groups.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/tag/x-tag-groups.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,6CAA6C,CAAA;AAgBpD,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,GAAG,YAAY,CAAA;AAEhB,eAAO,MAAM,SAAS;;;;;MAiBrB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;QA/CzB;;WAEG;;QAEH;;WAEG;;;;;EA2CL,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,SAAS,EAAE,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;EAYtB,CAAA"}
+{"version":3,"file":"x-tag-groups.d.ts","sourceRoot":"","sources":["../../../../src/schemas/extensions/tag/x-tag-groups.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,6CAA6C,CAAA;AAgBpD,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAA;CACf,GAAG,YAAY,CAAA;AAEhB,eAAO,MAAM,SAAS;;;;;IAiBrB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;QA/CzB;;WAEG;;QAEH;;WAEG;;;;;EA2CL,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB;;;;OAIG;IACH,aAAa,CAAC,EAAE,SAAS,EAAE,CAAA;CAC5B,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;EAYtB,CAAA"}

package/dist/schemas/v3.1/openapi/index.d.ts

@@ -1,3 +1,112 @@
 import { type Schema } from '@scalar/validation';
-export declare const generateSchema: (maybeRef: (inner: Schema) => Schema) => import("@scalar/validation").IntersectionSchema<readonly import("@scalar/validation").ObjectSchema<any>[]>;
+export declare const generateSchema: (maybeRef: (inner: Schema) => Schema) => import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+    openapi: import("@scalar/validation").StringSchema;
+    info: import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        title: import("@scalar/validation").StringSchema;
+        version: import("@scalar/validation").StringSchema;
+        summary: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        termsOfService: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        contact: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            email: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>;
+        license: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            identifier: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            url: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-sdk-installation': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            lang: import("@scalar/validation").StringSchema;
+            source: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+    }>]>;
+    jsonSchemaDialect: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    servers: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        variables: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+            enum: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+            default: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>>;
+    }>>>;
+    paths: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<Record<string, any>>>>;
+    webhooks: import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<Record<string, any>>>>;
+    components: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<Record<string, any>>>;
+    security: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>>>;
+    tags: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        externalDocs: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+            url: import("@scalar/validation").StringSchema;
+            description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        }>>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-displayName': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-internal': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-ignore': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>]>>>;
+    externalDocs: import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        url: import("@scalar/validation").StringSchema;
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    }>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-original-oas-version': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    'x-scalar-original-source-url': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+    "x-scalar-navigation": import("@scalar/validation").OptionalSchema<import("@scalar/validation").AnySchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-tagGroups': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").IntersectionSchema<readonly [import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        tags: import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>;
+    }>, import("@scalar/validation").ObjectSchema<{
+        'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+    }>]>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-environments': import("@scalar/validation").OptionalSchema<import("@scalar/validation").RecordSchema<import("@scalar/validation").StringSchema, import("@scalar/validation").ObjectSchema<{
+        description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        color: import("@scalar/validation").StringSchema;
+        variables: import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+            name: import("@scalar/validation").StringSchema;
+            value: import("@scalar/validation").UnionSchema<(import("@scalar/validation").StringSchema | import("@scalar/validation").ObjectSchema<{
+                description: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+                default: import("@scalar/validation").StringSchema;
+            }>)[]>;
+        }>>;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-selected-server': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-icon': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-order': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").StringSchema>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-cookies': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ArraySchema<import("@scalar/validation").ObjectSchema<{
+        name: import("@scalar/validation").StringSchema;
+        value: import("@scalar/validation").StringSchema;
+        domain: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        path: import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+        isDisabled: import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+    }>>>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-original-document-hash': import("@scalar/validation").StringSchema;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-is-dirty': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-active-environment': import("@scalar/validation").OptionalSchema<import("@scalar/validation").StringSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-watch-mode': import("@scalar/validation").OptionalSchema<import("@scalar/validation").BooleanSchema>;
+}>, import("@scalar/validation").ObjectSchema<{
+    'x-scalar-registry-meta': import("@scalar/validation").OptionalSchema<import("@scalar/validation").ObjectSchema<{
+        namespace: import("@scalar/validation").StringSchema;
+        slug: import("@scalar/validation").StringSchema;
+    }>>;
+}>]>;
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/v3.1/openapi/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.1/openapi/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AAyC3B,eAAO,MAAM,cAAc,GAAI,UAAU,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,+GAgiCjE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/schemas/v3.1/openapi/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EAaZ,MAAM,oBAAoB,CAAA;AAyC3B,eAAO,MAAM,cAAc,GAAI,UAAU,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6gCjE,CAAA"}

package/dist/schemas/v3.1/openapi/index.js

@@ -150,7 +150,7 @@ export const generateSchema = (maybeRef) => {
         XAdditionalPropertiesName,
         XTags,
     ];
-    const coreSchemaProperties = {
+    const coreSchemaProperties = object({
         name: optional(string({ typeComment: 'Schema name (extension).' })),
         title: optional(string({ typeComment: 'A title for the schema.' })),
         description: optional(string({ typeComment: 'A description of the schema.' })),
@@ -177,64 +177,46 @@ export const generateSchema = (maybeRef) => {
         oneOf: optional(array(maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectOneOf' })),
         anyOf: optional(array(maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectAnyOf' })),
         not: optional(maybeRef(lazy(() => schema))),
-    };
-    const schemaScalarMarker = intersection([
-        object({ __scalar_: string({ typeComment: 'Internal marker for schema object disambiguation.' }) }),
-        object(coreSchemaProperties, { typeName: 'JsonSchemaCoreMarked' }),
-        ...schemaExtensionObjects,
-    ]);
-    const numericSchema = intersection([
-        object({
-            ...coreSchemaProperties,
-            type: union([literal('number'), literal('integer')]),
-            format: optional(string({ typeComment: 'Different subtypes.' })),
-            multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
-            maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
-            exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
-            minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
-            exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
-        }, { typeName: 'NumberSchemaObject' }),
-        ...schemaExtensionObjects,
-    ]);
-    const stringSchema = intersection([
-        object({
-            ...coreSchemaProperties,
-            type: literal('string'),
-            format: optional(string({ typeComment: 'Different subtypes.' })),
-            maxLength: optional(number({ typeComment: 'Maximum string length.' })),
-            minLength: optional(number({ typeComment: 'Minimum string length.' })),
-            pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
-        }, { typeName: 'StringSchemaObject' }),
-        ...schemaExtensionObjects,
-    ]);
-    const objectSchema = intersection([
-        object({
-            ...coreSchemaProperties,
-            type: literal('object'),
-            maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
-            minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
-            properties: optional(record(string(), maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectProperties' })),
-            required: optional(array(string(), { typeName: 'SchemaObjectRequired' })),
-            additionalProperties: optional(union([boolean(), maybeRef(lazy(() => schema))], {
-                typeName: 'SchemaObjectAdditionalProperties',
-            })),
-            patternProperties: optional(record(string(), maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectPatternProperties' })),
-            propertyNames: optional(maybeRef(lazy(() => schema))),
-        }, { typeName: 'ObjectSchemaObject' }),
-        ...schemaExtensionObjects,
-    ]);
-    const arraySchema = intersection([
-        object({
-            ...coreSchemaProperties,
-            type: literal('array'),
-            maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
-            minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
-            uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
-            items: optional(maybeRef(lazy(() => schema))),
-            prefixItems: optional(array(maybeRef(lazy(() => schema)), { typeComment: 'Schema for tuple validation.' })),
-        }, { typeName: 'ArraySchemaObject' }),
-        ...schemaExtensionObjects,
-    ]);
+    });
+    const schemaScalarMarker = object({
+        __scalar_: string({ typeComment: 'Internal marker for schema object disambiguation.' }),
+    });
+    const numericSchema = object({
+        type: union([literal('number'), literal('integer')]),
+        format: optional(string({ typeComment: 'Different subtypes.' })),
+        multipleOf: optional(number({ typeComment: 'Number must be a multiple of this value.' })),
+        maximum: optional(number({ typeComment: 'Maximum value (inclusive).' })),
+        exclusiveMaximum: optional(number({ typeComment: 'Maximum value (exclusive).' })),
+        minimum: optional(number({ typeComment: 'Minimum value (inclusive).' })),
+        exclusiveMinimum: optional(number({ typeComment: 'Minimum value (exclusive).' })),
+    }, { typeName: 'NumberSchemaObject' });
+    const stringSchema = object({
+        type: literal('string'),
+        format: optional(string({ typeComment: 'Different subtypes.' })),
+        maxLength: optional(number({ typeComment: 'Maximum string length.' })),
+        minLength: optional(number({ typeComment: 'Minimum string length.' })),
+        pattern: optional(string({ typeComment: 'Regular expression pattern.' })),
+    }, { typeName: 'StringSchemaObject' });
+    const objectSchema = object({
+        type: literal('object'),
+        maxProperties: optional(number({ typeComment: 'Maximum number of properties.' })),
+        minProperties: optional(number({ typeComment: 'Minimum number of properties.' })),
+        properties: optional(record(string(), maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectProperties' })),
+        required: optional(array(string(), { typeName: 'SchemaObjectRequired' })),
+        additionalProperties: optional(union([boolean(), maybeRef(lazy(() => schema))], {
+            typeName: 'SchemaObjectAdditionalProperties',
+        })),
+        patternProperties: optional(record(string(), maybeRef(lazy(() => schema)), { typeName: 'SchemaObjectPatternProperties' })),
+        propertyNames: optional(maybeRef(lazy(() => schema))),
+    }, { typeName: 'ObjectSchemaObject' });
+    const arraySchema = object({
+        type: literal('array'),
+        maxItems: optional(number({ typeComment: 'Maximum number of items in array.' })),
+        minItems: optional(number({ typeComment: 'Minimum number of items in array.' })),
+        uniqueItems: optional(boolean({ typeComment: 'Whether array items must be unique.' })),
+        items: optional(maybeRef(lazy(() => schema))),
+        prefixItems: optional(array(maybeRef(lazy(() => schema)), { typeComment: 'Schema for tuple validation.' })),
+    }, { typeName: 'ArraySchemaObject' });
     const schemaTypeMulti = union([
         literal('null'),
         literal('boolean'),
@@ -244,14 +226,16 @@ export const generateSchema = (maybeRef) => {
         literal('object'),
         literal('array'),
     ], { typeName: 'SchemaObjectMultiTypeKeywords' });
-    const otherTypeSchema = intersection([
-        object({
-            ...coreSchemaProperties,
-            type: union([literal('null'), literal('boolean'), array(schemaTypeMulti, { typeName: 'SchemaObjectTypeKeywordList' })], { typeName: 'SchemaObjectOtherTypeKeyword' }),
-        }, { typeName: 'MultiTypeSchemaObject' }),
+    const otherTypeSchema = object({
+        type: union([literal('null'), literal('boolean'), array(schemaTypeMulti)], {
+            typeName: 'SchemaObjectOtherTypeKeyword',
+        }),
+    }, { typeName: 'MultiTypeSchemaObject' });
+    const schema = intersection([
+        coreSchemaProperties,
         ...schemaExtensionObjects,
-    ]);
-    const schema = union([schemaScalarMarker, otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema], { typeName: 'SchemaObject' });
+        union([schemaScalarMarker, otherTypeSchema, numericSchema, stringSchema, objectSchema, arraySchema]),
+    ], { typeName: 'SchemaObject' });
     const securitySchemeBase = object({
         description: optional(string({
             typeComment: 'A description for security scheme. CommonMark syntax MAY be used for rich text representation.',

package/package.json

@@ -16,7 +16,7 @@
     "openapi",
     "scalar"
   ],
-  "version": "0.42.0",
+  "version": "0.43.1",
   "engines": {
     "node": ">=22"
   },
@@ -72,6 +72,11 @@
       "types": "./dist/plugins/client/index.d.ts",
       "default": "./dist/plugins/client/index.js"
     },
+    "./request-example": {
+      "import": "./dist/request-example/index.js",
+      "types": "./dist/request-example/index.d.ts",
+      "default": "./dist/request-example/index.js"
+    },
     "./resolve": {
       "import": "./dist/resolve.js",
       "types": "./dist/resolve.d.ts",
@@ -135,21 +140,21 @@
   "dependencies": {
     "@scalar/typebox": "0.1.3",
     "github-slugger": "2.0.0",
+    "js-base64": "^3.7.8",
     "type-fest": "^5.3.1",
-    "vue": "^3.5.26",
+    "vue": "^3.5.30",
     "yaml": "^2.8.0",
-    "@scalar/code-highlight": "0.3.1",
-    "@scalar/helpers": "0.4.2",
-    "@scalar/json-magic": "0.12.4",
-    "@scalar/openapi-upgrader": "0.2.3",
-    "@scalar/snippetz": "0.7.7",
-    "@scalar/types": "0.7.5",
-    "@scalar/validation": "0.2.0"
+    "@scalar/helpers": "0.4.3",
+    "@scalar/json-magic": "0.12.5",
+    "@scalar/openapi-upgrader": "0.2.4",
+    "@scalar/snippetz": "0.7.8",
+    "@scalar/types": "0.7.6",
+    "@scalar/validation": "0.3.0"
   },
   "devDependencies": {
     "@google-cloud/storage": "7.16.0",
     "fake-indexeddb": "6.2.3",
-    "fastify": "^5.3.3",
+    "fastify": "^5.8.1",
     "vite": "8.0.0",
     "vitest": "4.1.0"
   },