@scalar/workspace-store 0.51.2 → 0.53.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @scalar/workspace-store
 
+## 0.53.0
+
+### Minor Changes
+
+- [#9340](https://github.com/scalar/scalar/pull/9340): feat: add getChannelConnectionContext for AsyncAPI WebSocket channels
+
+  Add channel connection context helpers that resolve channel, messages, parameters, servers, security, and connection URL for WebSocket client UI.
+
+- [#9372](https://github.com/scalar/scalar/pull/9372): Render AsyncAPI `components.schemas` as Models, listed in the sidebar and content just like OpenAPI schemas
+- [#9331](https://github.com/scalar/scalar/pull/9331): feat: generate AsyncAPI sidebar navigation on document ingest
+
+  Add `TraversedAsyncApiChannel`, `TraversedAsyncApiOperation`, and `TraversedAsyncApiMessage` navigation entry types, plus `traverseAsyncApiDocument` wired into the AsyncAPI ingest path. Navigation is structured as channel → operation → message, with messages resolved per operation (all channel messages by default, or filtered via `operation.messages`).
+
+### Patch Changes
+
+- [#9255](https://github.com/scalar/scalar/pull/9255): Surface the Introduction entry and any headings extracted from `info.description` of AsyncAPI documents in the sidebar, mirroring how OpenAPI documents are handled.
+- [#9309](https://github.com/scalar/scalar/pull/9309): feat: add `modelsSectionLabel` configuration (`'Models' | 'Schemas' | string`) to use OpenAPI-style Schemas terminology in the sidebar, content, and search.
+- [#9383](https://github.com/scalar/scalar/pull/9383): fix: preserve multi-type schema arrays when coercing schemas with validation keywords
+
+## 0.52.0
+
+### Minor Changes
+
+- [#9313](https://github.com/scalar/scalar/pull/9313): feat: add AsyncAPI connection URL builder and server list helpers
+
+### Patch Changes
+
+- [#9334](https://github.com/scalar/scalar/pull/9334): Add analytics events for document save and registry sync (pull/push) actions
+- [#9333](https://github.com/scalar/scalar/pull/9333): feat: respect the `x-order` extension when building schema examples
+
 ## 0.51.2
 
 ## 0.51.1

package/dist/channel-example/build-connection-url.d.ts

@@ -0,0 +1,42 @@
+import type { AsyncApiChannelObject, AsyncApiOperationObject, AsyncApiServerObject, AsyncApiWsBindingObject } from '@scalar/types/asyncapi/3.1';
+/** AsyncAPI server protocols supported for WebSocket connections in the API client MVP. */
+export declare const ASYNCAPI_WEBSOCKET_PROTOCOLS: readonly ["ws", "wss"];
+export type AsyncApiWebSocketProtocol = (typeof ASYNCAPI_WEBSOCKET_PROTOCOLS)[number];
+export type BuildConnectionUrlInput = {
+    server: AsyncApiServerObject;
+    channel: AsyncApiChannelObject;
+    operation?: AsyncApiOperationObject | null;
+    pathParameters?: Record<string, string>;
+    queryParameters?: Record<string, string>;
+    environmentVariables?: Record<string, string> | ((key: string) => string | null);
+};
+/**
+ * Extracts default values of variables defined on an AsyncAPI Server Object.
+ */
+export declare const getAsyncApiServerVariables: (server: AsyncApiServerObject | null) => Record<string, string>;
+/** Maps AsyncAPI `server.protocol` to a URL scheme (MVP: ws and wss). */
+export declare const getUrlSchemeFromProtocol: (protocol: string) => string;
+export declare const isWebSocketProtocol: (protocol: string) => protocol is AsyncApiWebSocketProtocol;
+/**
+ * Builds the server base URL: scheme, host, and optional pathname (no channel address).
+ */
+export declare const buildAsyncApiServerBaseUrl: (server: AsyncApiServerObject, environmentVariables?: BuildConnectionUrlInput["environmentVariables"]) => string;
+/** Merges channel and operation WebSocket bindings; operation fields override channel. */
+export declare const mergeWsBindings: (channel: AsyncApiChannelObject, operation?: AsyncApiOperationObject | null) => AsyncApiWsBindingObject | undefined;
+/**
+ * Builds handshake query parameters from merged `bindings.ws.query` schema defaults,
+ * then applies explicit overrides.
+ */
+export declare const buildWsQueryParams: (wsBinding: AsyncApiWsBindingObject | undefined, queryParameters?: Record<string, string>) => URLSearchParams;
+/**
+ * Builds a WebSocket connection URL from a resolved server, channel, and optional operation.
+ *
+ * Composition (AsyncAPI 3.x):
+ * 1. `server.protocol` → URL scheme
+ * 2. `server.host` (+ variables and environment substitution)
+ * 3. Optional `server.pathname`
+ * 4. Channel `address` (+ path parameter substitution)
+ * 5. Query string from merged `bindings.ws.query` (channel + operation) with schema defaults
+ */
+export declare const buildConnectionUrl: ({ server, channel, operation, pathParameters, queryParameters, environmentVariables, }: BuildConnectionUrlInput) => string;
+//# sourceMappingURL=build-connection-url.d.ts.map

package/dist/channel-example/build-connection-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-connection-url.d.ts","sourceRoot":"","sources":["../../src/channel-example/build-connection-url.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,4BAA4B,CAAA;AAInC,2FAA2F;AAC3F,eAAO,MAAM,4BAA4B,wBAAyB,CAAA;AAElE,MAAM,MAAM,yBAAyB,GAAG,CAAC,OAAO,4BAA4B,CAAC,CAAC,MAAM,CAAC,CAAA;AAErF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,oBAAoB,CAAA;IAC5B,OAAO,EAAE,qBAAqB,CAAA;IAC9B,SAAS,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAA;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC,CAAA;CACjF,CAAA;AAQD;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,QAAQ,oBAAoB,GAAG,IAAI,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAYrG,CAAA;AAoBD,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,GAAI,UAAU,MAAM,KAAG,MAAuC,CAAA;AAEnG,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,KAAG,QAAQ,IAAI,yBAC0B,CAAA;AAE7F;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACrC,QAAQ,oBAAoB,EAC5B,uBAAuB,uBAAuB,CAAC,sBAAsB,CAAC,KACrE,MAYF,CAAA;AAaD,0FAA0F;AAC1F,eAAO,MAAM,eAAe,GAC1B,SAAS,qBAAqB,EAC9B,YAAY,uBAAuB,GAAG,IAAI,KACzC,uBAAuB,GAAG,SAa5B,CAAA;AA0FD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,WAAW,uBAAuB,GAAG,SAAS,EAC9C,kBAAkB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACvC,eAoBF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,wFAOhC,uBAAuB,KAAG,MAkB5B,CAAA"}

package/dist/channel-example/build-connection-url.js

@@ -0,0 +1,184 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { objectEntries } from '@scalar/helpers/object/object-entries';
+import { replaceEnvVariables, replacePathVariables } from '@scalar/helpers/regex/replace-variables';
+import { combineUrlAndPath, mergeUrls } from '@scalar/helpers/url/merge-urls';
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+/** AsyncAPI server protocols supported for WebSocket connections in the API client MVP. */
+export const ASYNCAPI_WEBSOCKET_PROTOCOLS = ['ws', 'wss'];
+/**
+ * Extracts default values of variables defined on an AsyncAPI Server Object.
+ */
+export const getAsyncApiServerVariables = (server) => {
+    if (!server?.variables) {
+        return {};
+    }
+    return objectEntries(server.variables).reduce((acc, [name, variable]) => {
+        const resolved = getResolvedRef(variable);
+        if (resolved.default != null) {
+            acc[String(name)] = String(resolved.default);
+        }
+        return acc;
+    }, {});
+};
+const substituteTemplate = (template, options) => {
+    let result = template;
+    if (options.serverVariables) {
+        result = replacePathVariables(result, options.serverVariables);
+    }
+    if (options.environmentVariables) {
+        result = replaceEnvVariables(result, options.environmentVariables);
+    }
+    if (options.pathParameters) {
+        result = replacePathVariables(result, options.pathParameters);
+    }
+    return result;
+};
+/** Maps AsyncAPI `server.protocol` to a URL scheme (MVP: ws and wss). */
+export const getUrlSchemeFromProtocol = (protocol) => protocol.trim().toLowerCase();
+export const isWebSocketProtocol = (protocol) => ASYNCAPI_WEBSOCKET_PROTOCOLS.includes(protocol.trim().toLowerCase());
+/**
+ * Builds the server base URL: scheme, host, and optional pathname (no channel address).
+ */
+export const buildAsyncApiServerBaseUrl = (server, environmentVariables) => {
+    const serverVariables = getAsyncApiServerVariables(server);
+    const scheme = getUrlSchemeFromProtocol(server.protocol);
+    const host = substituteTemplate(server.host, { serverVariables, environmentVariables });
+    const origin = `${scheme}://${host}`;
+    if (!server.pathname) {
+        return origin;
+    }
+    const pathname = substituteTemplate(server.pathname, { serverVariables, environmentVariables });
+    return combineUrlAndPath(origin, pathname);
+};
+const resolveWsBinding = (bindings) => {
+    if (!bindings) {
+        return undefined;
+    }
+    const resolved = getResolvedRef(bindings);
+    return resolved.ws;
+};
+/** Merges channel and operation WebSocket bindings; operation fields override channel. */
+export const mergeWsBindings = (channel, operation) => {
+    const channelBinding = resolveWsBinding(channel.bindings);
+    const operationBinding = operation ? resolveWsBinding(operation.bindings) : undefined;
+    if (!channelBinding && !operationBinding) {
+        return undefined;
+    }
+    return {
+        ...channelBinding,
+        ...operationBinding,
+        query: mergeWsQuerySchemas(channelBinding?.query, operationBinding?.query),
+    };
+};
+const resolveWsQuerySchema = (query) => {
+    if (!query) {
+        return undefined;
+    }
+    const resolved = getResolvedRef(query);
+    if (resolved === true || resolved === false || !isObject(resolved)) {
+        return undefined;
+    }
+    return resolved;
+};
+const mergeWsQuerySchemas = (channelQuery, operationQuery) => {
+    const channelSchema = resolveWsQuerySchema(channelQuery);
+    const operationSchema = resolveWsQuerySchema(operationQuery);
+    if (!channelSchema && !operationSchema) {
+        return undefined;
+    }
+    if (!channelSchema) {
+        return operationQuery;
+    }
+    if (!operationSchema) {
+        return channelQuery;
+    }
+    // `properties` only exists on the object-schema branch of the Schema Object union,
+    // so reach it through an `in` check rather than assuming it is present.
+    const channelProperties = 'properties' in channelSchema ? channelSchema.properties : undefined;
+    const operationProperties = 'properties' in operationSchema ? operationSchema.properties : undefined;
+    // Merge via Object.assign so the result is an intersection of the two schemas rather than a
+    // distributed union of every Schema Object variant, which keeps it assignable to the query type.
+    return Object.assign({}, channelSchema, operationSchema, {
+        properties: {
+            ...channelProperties,
+            ...operationProperties,
+        },
+    });
+};
+const getDefaultValueFromPropertySchema = (propertySchema) => {
+    if (propertySchema === true || propertySchema === false || !isObject(propertySchema)) {
+        return undefined;
+    }
+    if ('default' in propertySchema && propertySchema.default !== undefined) {
+        return propertySchema.default;
+    }
+    if ('example' in propertySchema && propertySchema.example !== undefined) {
+        return propertySchema.example;
+    }
+    if ('enum' in propertySchema && Array.isArray(propertySchema.enum) && propertySchema.enum[0] !== undefined) {
+        return propertySchema.enum[0];
+    }
+    return undefined;
+};
+const appendQueryValue = (params, key, value) => {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => appendQueryValue(params, key, entry));
+        return;
+    }
+    if (typeof value === 'object') {
+        params.append(key, JSON.stringify(value));
+        return;
+    }
+    params.append(key, String(value));
+};
+/**
+ * Builds handshake query parameters from merged `bindings.ws.query` schema defaults,
+ * then applies explicit overrides.
+ */
+export const buildWsQueryParams = (wsBinding, queryParameters) => {
+    const params = new URLSearchParams();
+    const querySchema = resolveWsQuerySchema(wsBinding?.query);
+    const properties = querySchema && 'properties' in querySchema ? querySchema.properties : undefined;
+    if (isObject(properties)) {
+        for (const [name, propertySchema] of Object.entries(properties)) {
+            const defaultValue = getDefaultValueFromPropertySchema(propertySchema);
+            appendQueryValue(params, name, defaultValue);
+        }
+    }
+    if (queryParameters) {
+        for (const [name, value] of objectEntries(queryParameters)) {
+            params.delete(name);
+            appendQueryValue(params, name, value);
+        }
+    }
+    return params;
+};
+/**
+ * Builds a WebSocket connection URL from a resolved server, channel, and optional operation.
+ *
+ * Composition (AsyncAPI 3.x):
+ * 1. `server.protocol` → URL scheme
+ * 2. `server.host` (+ variables and environment substitution)
+ * 3. Optional `server.pathname`
+ * 4. Channel `address` (+ path parameter substitution)
+ * 5. Query string from merged `bindings.ws.query` (channel + operation) with schema defaults
+ */
+export const buildConnectionUrl = ({ server, channel, operation = null, pathParameters = {}, queryParameters = {}, environmentVariables, }) => {
+    const serverVariables = getAsyncApiServerVariables(server);
+    const baseUrl = buildAsyncApiServerBaseUrl(server, environmentVariables);
+    const address = channel.address;
+    if (address == null || address === '') {
+        const queryParams = buildWsQueryParams(mergeWsBindings(channel, operation), queryParameters);
+        return mergeUrls(baseUrl, '', queryParams, true);
+    }
+    const resolvedAddress = substituteTemplate(address, {
+        serverVariables,
+        environmentVariables,
+        pathParameters,
+    });
+    const queryParams = buildWsQueryParams(mergeWsBindings(channel, operation), queryParameters);
+    return mergeUrls(baseUrl, resolvedAddress, queryParams, true);
+};

package/dist/channel-example/get-all-channel-messages.d.ts

@@ -0,0 +1,10 @@
+import type { AsyncApiChannelObject, AsyncApiDocument, AsyncApiMessageObject } from '@scalar/types/asyncapi/3.1';
+export type ChannelMessageEntry = {
+    name: string;
+    message: AsyncApiMessageObject;
+};
+/**
+ * Resolves every message defined on a channel (AsyncAPI data store for payloads).
+ */
+export declare const getAllChannelMessages: (_document: AsyncApiDocument, channel: AsyncApiChannelObject) => ChannelMessageEntry[];
+//# sourceMappingURL=get-all-channel-messages.d.ts.map

package/dist/channel-example/get-all-channel-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-all-channel-messages.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-all-channel-messages.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAIhH,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,qBAAqB,CAAA;CAC/B,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAChC,WAAW,gBAAgB,EAC3B,SAAS,qBAAqB,KAC7B,mBAAmB,EAWrB,CAAA"}

package/dist/channel-example/get-all-channel-messages.js

@@ -0,0 +1,16 @@
+import { objectEntries } from '@scalar/helpers/object/object-entries';
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+/**
+ * Resolves every message defined on a channel (AsyncAPI data store for payloads).
+ */
+export const getAllChannelMessages = (_document, channel) => {
+    if (!channel.messages) {
+        return [];
+    }
+    return objectEntries(channel.messages)
+        .map(([name, messageRef]) => {
+        const message = getResolvedRef(messageRef);
+        return { name, message };
+    })
+        .filter((entry) => entry.message != null);
+};

package/dist/channel-example/get-asyncapi-security-requirements.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncApiDocument, AsyncApiOperationObject, AsyncApiServerObject } from '@scalar/types/asyncapi/3.1';
+import type { SecurityRequirementObject } from '../schemas/v3.1/strict/security-requirement.js';
+/**
+ * Converts AsyncAPI security arrays (operation, traits, server) into OpenAPI-style requirement objects.
+ */
+export declare const getAsyncApiSecurityRequirements: (document: AsyncApiDocument, operation?: AsyncApiOperationObject | null, server?: AsyncApiServerObject | null) => SecurityRequirementObject[];
+//# sourceMappingURL=get-asyncapi-security-requirements.d.ts.map

package/dist/channel-example/get-asyncapi-security-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-asyncapi-security-requirements.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-asyncapi-security-requirements.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EAEvB,oBAAoB,EACrB,MAAM,4BAA4B,CAAA;AAInC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAA;AA6E3F;;GAEG;AACH,eAAO,MAAM,+BAA+B,GAC1C,UAAU,gBAAgB,EAC1B,YAAY,uBAAuB,GAAG,IAAI,EAC1C,SAAS,oBAAoB,GAAG,IAAI,KACnC,yBAAyB,EAqB3B,CAAA"}

package/dist/channel-example/get-asyncapi-security-requirements.js

@@ -0,0 +1,76 @@
+import { isObjectEqual } from '@scalar/helpers/object/is-object-equal';
+import { getNameFromRef } from '../helpers/get-name-from-ref.js';
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+const getSecuritySchemeNameFromRef = (ref) => getNameFromRef(ref, ['components', 'securitySchemes']);
+/** Strips requirement-only `scopes` so inline entries can match component scheme definitions. */
+const getSecuritySchemeDefinition = (entry) => {
+    const resolved = getResolvedRef(entry);
+    if (resolved == null) {
+        return undefined;
+    }
+    if (!('scopes' in resolved)) {
+        return resolved;
+    }
+    const { scopes: _scopes, ...scheme } = resolved;
+    return scheme;
+};
+const getSecuritySchemeName = (document, entry) => {
+    if ('$ref' in entry) {
+        const nameFromRef = getSecuritySchemeNameFromRef(entry.$ref);
+        if (nameFromRef) {
+            return nameFromRef;
+        }
+    }
+    const resolvedDefinition = getSecuritySchemeDefinition(entry);
+    if (resolvedDefinition == null) {
+        return undefined;
+    }
+    const components = document.components ? getResolvedRef(document.components) : undefined;
+    if (components?.securitySchemes) {
+        for (const [name, schemeRef] of Object.entries(components.securitySchemes)) {
+            const scheme = getResolvedRef(schemeRef);
+            if (scheme === resolvedDefinition || isObjectEqual(scheme, resolvedDefinition)) {
+                return name;
+            }
+        }
+    }
+    return undefined;
+};
+const securityEntryToRequirement = (document, entry) => {
+    const schemeName = getSecuritySchemeName(document, entry);
+    if (!schemeName) {
+        return undefined;
+    }
+    const resolved = getResolvedRef(entry);
+    const scopes = resolved != null && 'scopes' in resolved && Array.isArray(resolved.scopes) ? [...resolved.scopes] : [];
+    return { [schemeName]: scopes };
+};
+const collectSecurityRequirements = (document, security) => {
+    if (!security?.length) {
+        return [];
+    }
+    return security
+        .map((entry) => securityEntryToRequirement(document, entry))
+        .filter((requirement) => requirement != null);
+};
+/**
+ * Converts AsyncAPI security arrays (operation, traits, server) into OpenAPI-style requirement objects.
+ */
+export const getAsyncApiSecurityRequirements = (document, operation, server) => {
+    const operationRequirements = collectSecurityRequirements(document, operation?.security);
+    const serverRequirements = collectSecurityRequirements(document, server?.security);
+    const combined = operationRequirements.length === 0
+        ? serverRequirements
+        : serverRequirements.length === 0
+            ? operationRequirements
+            : [...operationRequirements, ...serverRequirements];
+    const seen = new Set();
+    return combined.filter((requirement) => {
+        const key = JSON.stringify(requirement);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+};

package/dist/channel-example/get-channel-connection-context.d.ts

@@ -0,0 +1,16 @@
+import type { AuthenticationConfiguration } from '@scalar/types/api-reference';
+import type { BuildChannelConnectionContext, ChannelConnectionMeta } from '../channel-example/types.js';
+import type { WorkspaceStore } from '../client.js';
+import type { Result } from '../request-example/types.js';
+import type { WorkspaceDocument } from '../schemas/workspace.js';
+/**
+ * Builds context for testing a WebSocket channel (Postman-style): one connection per channel,
+ * with AsyncAPI messages, servers, and parameters as the data store.
+ */
+export declare const getChannelConnectionContext: (workspaceStore: WorkspaceStore, documentName: string, channelConnectionMeta: ChannelConnectionMeta, options?: Partial<{
+    pathParameters: Record<string, string>;
+    queryParameters: Record<string, string>;
+    authentication: AuthenticationConfiguration;
+    fallbackDocument: WorkspaceDocument | null;
+}>) => Result<BuildChannelConnectionContext>;
+//# sourceMappingURL=get-channel-connection-context.d.ts.map

package/dist/channel-example/get-channel-connection-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-channel-connection-context.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-channel-connection-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAS9E,OAAO,KAAK,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AACnG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAQ9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAGrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GACtC,gBAAgB,cAAc,EAC9B,cAAc,MAAM,EACpB,uBAAuB,qBAAqB,EAC5C,UAAS,OAAO,CAAC;IACf,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,cAAc,EAAE,2BAA2B,CAAA;IAC3C,gBAAgB,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAC3C,CAAM,KACN,MAAM,CAAC,6BAA6B,CAwItC,CAAA"}

package/dist/channel-example/get-channel-connection-context.js

@@ -0,0 +1,120 @@
+import { buildConnectionUrl } from '../channel-example/build-connection-url.js';
+import { getAllChannelMessages } from '../channel-example/get-all-channel-messages.js';
+import { getChannelConnectionSecurityRequirements } from '../channel-example/get-channel-connection-security.js';
+import { getChannelOperations } from '../channel-example/get-channel-operations.js';
+import { getChannelParameters } from '../channel-example/get-channel-parameters.js';
+import { resolveChannel } from '../channel-example/resolve-channel.js';
+import { getAsyncApiServers, getSelectedAsyncApiServer } from '../channel-example/servers.js';
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+import { getEnvironmentVariables } from '../request-example/builder/helpers/get-environment-variables.js';
+import { getActiveEnvironment } from '../request-example/context/environment.js';
+import { getSecuritySchemes } from '../request-example/context/security/get-security-schemes.js';
+import { getSelectedSecurity } from '../request-example/context/security/get-selected-security.js';
+import { mergeSecurity } from '../request-example/context/security/merge-security.js';
+import { isAsyncApiDocument } from '../schemas/type-guards.js';
+/** Uses channel name as the auth path key for AsyncAPI channel connections. */
+const ASYNCAPI_CHANNEL_AUTH_METHOD = 'get';
+/**
+ * Builds context for testing a WebSocket channel (Postman-style): one connection per channel,
+ * with AsyncAPI messages, servers, and parameters as the data store.
+ */
+export const getChannelConnectionContext = (workspaceStore, documentName, channelConnectionMeta, options = {}) => {
+    const { channelName } = channelConnectionMeta;
+    const document = workspaceStore.workspace.documents[documentName] ?? options.fallbackDocument ?? undefined;
+    if (!document) {
+        return {
+            ok: false,
+            error: `Document ${documentName} not found`,
+        };
+    }
+    if (!isAsyncApiDocument(document)) {
+        return {
+            ok: false,
+            error: `Document ${documentName} is not an AsyncAPI document`,
+        };
+    }
+    const resolvedChannel = resolveChannel(document, channelName);
+    if (!resolvedChannel) {
+        return {
+            ok: false,
+            error: `Channel ${channelName} not found`,
+        };
+    }
+    const { channel, channelAddress } = resolvedChannel;
+    const environment = getActiveEnvironment(workspaceStore, document);
+    const environmentVariables = getEnvironmentVariables(environment.environment);
+    const channelOperations = getChannelOperations(document, channelName);
+    const parameters = getChannelParameters(channel, null, {
+        path: options.pathParameters,
+        query: options.queryParameters,
+    });
+    const servers = getAsyncApiServers(document, {
+        channel,
+        operation: null,
+        pathParameters: parameters.path,
+        queryParameters: parameters.query,
+        environmentVariables,
+    });
+    const selectedServer = getSelectedAsyncApiServer(document, servers, null);
+    const serverForUrl = selectedServer?.server ?? servers[0]?.server;
+    if (!serverForUrl) {
+        return {
+            ok: false,
+            error: `No WebSocket servers available for channel ${channelName}`,
+        };
+    }
+    const connectionUrl = selectedServer?.connectionUrl ??
+        buildConnectionUrl({
+            server: serverForUrl,
+            channel,
+            operation: null,
+            pathParameters: parameters.path,
+            queryParameters: parameters.query,
+            environmentVariables,
+        });
+    const messages = getAllChannelMessages(document, channel);
+    const selectedMessage = messages[0] ?? null;
+    const documentSelectedSecurity = workspaceStore.auth.getAuthSelectedSchemas({
+        type: 'document',
+        documentName,
+    });
+    const channelSelectedSecurity = workspaceStore.auth.getAuthSelectedSchemas({
+        type: 'operation',
+        documentName,
+        path: channelName,
+        method: ASYNCAPI_CHANNEL_AUTH_METHOD,
+    });
+    const components = document.components ? getResolvedRef(document.components) : undefined;
+    const securitySchemes = mergeSecurity((components?.securitySchemes ?? {}), options.authentication?.securitySchemes ?? {}, workspaceStore.auth, documentName);
+    const securityRequirements = getChannelConnectionSecurityRequirements(document, channel, selectedServer?.server ?? null, channelOperations);
+    const selectedSecurity = getSelectedSecurity(documentSelectedSecurity, channelSelectedSecurity, securityRequirements, securitySchemes, options.authentication?.preferredSecurityScheme);
+    const selectedSecuritySchemes = getSecuritySchemes(securitySchemes, selectedSecurity.selectedSchemes[selectedSecurity.selectedIndex] ?? {});
+    const authMeta = channelSelectedSecurity
+        ? { type: 'operation', path: channelName, method: ASYNCAPI_CHANNEL_AUTH_METHOD }
+        : { type: 'document' };
+    return {
+        ok: true,
+        data: {
+            channel,
+            channelName,
+            channelAddress,
+            operations: channelOperations,
+            messages,
+            selectedMessage,
+            servers: {
+                list: servers,
+                selected: selectedServer,
+            },
+            connectionUrl,
+            parameters,
+            security: {
+                schemes: securitySchemes,
+                requirements: securityRequirements,
+                selected: selectedSecurity,
+                selectedSchemes: selectedSecuritySchemes,
+                meta: authMeta,
+            },
+            environment,
+        },
+    };
+};

package/dist/channel-example/get-channel-connection-security.d.ts

@@ -0,0 +1,8 @@
+import type { AsyncApiChannelObject, AsyncApiDocument, AsyncApiServerObject } from '@scalar/types/asyncapi/3.1';
+import type { SecurityRequirementObject } from '../schemas/v3.1/strict/security-requirement.js';
+import type { ChannelOperationSummary } from './get-channel-operations.js';
+/**
+ * Merges security requirements from the selected server and all operations on a channel.
+ */
+export declare const getChannelConnectionSecurityRequirements: (document: AsyncApiDocument, _channel: AsyncApiChannelObject, server: AsyncApiServerObject | null, channelOperations: ChannelOperationSummary[]) => SecurityRequirementObject[];
+//# sourceMappingURL=get-channel-connection-security.d.ts.map

package/dist/channel-example/get-channel-connection-security.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-channel-connection-security.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-channel-connection-security.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAG/G,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAA;AAE3F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAevE;;GAEG;AACH,eAAO,MAAM,wCAAwC,GACnD,UAAU,gBAAgB,EAC1B,UAAU,qBAAqB,EAC/B,QAAQ,oBAAoB,GAAG,IAAI,EACnC,mBAAmB,uBAAuB,EAAE,KAC3C,yBAAyB,EAQ3B,CAAA"}

package/dist/channel-example/get-channel-connection-security.js

@@ -0,0 +1,20 @@
+import { getAsyncApiSecurityRequirements } from '../channel-example/get-asyncapi-security-requirements.js';
+const dedupeRequirements = (requirements) => {
+    const seen = new Set();
+    return requirements.filter((requirement) => {
+        const key = JSON.stringify(requirement);
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+};
+/**
+ * Merges security requirements from the selected server and all operations on a channel.
+ */
+export const getChannelConnectionSecurityRequirements = (document, _channel, server, channelOperations) => {
+    const serverRequirements = getAsyncApiSecurityRequirements(document, null, server);
+    const operationRequirements = channelOperations.flatMap(({ operation }) => getAsyncApiSecurityRequirements(document, operation, null));
+    return dedupeRequirements([...serverRequirements, ...operationRequirements]);
+};

package/dist/channel-example/get-channel-operations.d.ts

@@ -0,0 +1,11 @@
+import type { AsyncApiDocument, AsyncApiOperationObject } from '@scalar/types/asyncapi/3.1';
+export type ChannelOperationSummary = {
+    operationName: string;
+    operation: AsyncApiOperationObject;
+    action: 'send' | 'receive';
+};
+/**
+ * Lists AsyncAPI operations that target a given channel (for reference in the channel connection UI).
+ */
+export declare const getChannelOperations: (document: AsyncApiDocument, channelName: string) => ChannelOperationSummary[];
+//# sourceMappingURL=get-channel-operations.d.ts.map

package/dist/channel-example/get-channel-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-channel-operations.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-channel-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAA;AAO3F,MAAM,MAAM,uBAAuB,GAAG;IACpC,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,uBAAuB,CAAA;IAClC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAC3B,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,gBAAgB,EAAE,aAAa,MAAM,KAAG,uBAAuB,EAgB7G,CAAA"}

package/dist/channel-example/get-channel-operations.js

@@ -0,0 +1,20 @@
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+import { resolveOperationChannel } from './resolve-operation-channel.js';
+import { resolveOperationWithTraits } from './resolve-operation-with-traits.js';
+/**
+ * Lists AsyncAPI operations that target a given channel (for reference in the channel connection UI).
+ */
+export const getChannelOperations = (document, channelName) => {
+    const operations = document.operations ?? {};
+    return Object.entries(operations)
+        .map(([operationName, operationRef]) => {
+        const operation = resolveOperationWithTraits(getResolvedRef(operationRef));
+        const resolved = resolveOperationChannel(document, operation);
+        if (resolved?.channelName !== channelName) {
+            return undefined;
+        }
+        const action = operation.action === 'send' ? 'send' : 'receive';
+        return { operationName, operation, action };
+    })
+        .filter((entry) => entry != null);
+};

package/dist/channel-example/get-channel-parameters.d.ts

@@ -0,0 +1,14 @@
+import type { AsyncApiChannelObject, AsyncApiOperationObject, AsyncApiParameterObject } from '@scalar/types/asyncapi/3.1';
+export type ChannelParametersContext = {
+    /** Resolved channel parameter definitions keyed by name. */
+    definitions: Record<string, AsyncApiParameterObject>;
+    /** Values substituted into the channel address path segments. */
+    path: Record<string, string>;
+    /** Values substituted into WebSocket handshake query parameters. */
+    query: Record<string, string>;
+};
+/**
+ * Builds default path and query parameter values from channel definitions and ws bindings.
+ */
+export declare const getChannelParameters: (channel: AsyncApiChannelObject, operation?: AsyncApiOperationObject | null, overrides?: Partial<Pick<ChannelParametersContext, "path" | "query">>) => ChannelParametersContext;
+//# sourceMappingURL=get-channel-parameters.d.ts.map

package/dist/channel-example/get-channel-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-channel-parameters.d.ts","sourceRoot":"","sources":["../../src/channel-example/get-channel-parameters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,4BAA4B,CAAA;AAKnC,MAAM,MAAM,wBAAwB,GAAG;IACrC,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IACpD,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B,CAAA;AA+BD;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAS,qBAAqB,EAC9B,YAAY,uBAAuB,GAAG,IAAI,EAC1C,YAAW,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAM,KACxE,wBAgCF,CAAA"}