@scalar/mock-server 0.11.0 → 0.12.0

package/dist/utils/deserialize-parameter.js

@@ -0,0 +1,297 @@
+/**
+ * Helpers for turning string-encoded request parameters back into the structured values that JSON
+ * Schema validation expects, following the OpenAPI `style`/`explode` serialization rules.
+ *
+ * @see https://spec.openapis.org/oas/v3.1.1.html#style-values
+ */
+/** Default serialization style per parameter location. */
+const DEFAULT_STYLE = {
+    query: 'form',
+    cookie: 'form',
+    path: 'simple',
+    header: 'simple',
+};
+/**
+ * Resolve the effective `style` and `explode` for a parameter, applying the OpenAPI defaults.
+ *
+ * `explode` defaults to `true` only for the `form` style and `false` for every other style, so the
+ * default depends on the resolved style rather than the location alone.
+ */
+export const resolveSerialization = (location, style, explode) => {
+    const resolvedStyle = style ?? DEFAULT_STYLE[location];
+    return { style: resolvedStyle, explode: explode ?? resolvedStyle === 'form' };
+};
+/**
+ * Whether any composed subschema satisfies the predicate, looking through `anyOf`/`oneOf`/`allOf`.
+ *
+ * Optional array/object parameters are commonly described as `anyOf: [{ type: 'array' }, { type: 'null' }]`
+ * (for example FastAPI/Pydantic `Optional[List[str]]`). Without unwrapping these we would treat the value
+ * as a plain string and skip style-aware deserialization. Mirrors `getStructuredType` in
+ * `@scalar/workspace-store`'s `de-serialize-parameter`.
+ */
+const matchesComposedSchema = (schema, predicate) => {
+    for (const keyword of ['anyOf', 'oneOf', 'allOf']) {
+        const subSchemas = schema[keyword];
+        if (Array.isArray(subSchemas)) {
+            for (const subSchema of subSchemas) {
+                if (subSchema && typeof subSchema === 'object' && predicate(subSchema)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+/** Whether a resolved schema describes an array, including the OpenAPI 3.1 `type: ['array', 'null']` form. */
+export const isArraySchema = (schema) => {
+    if (!schema) {
+        return false;
+    }
+    const type = schema.type;
+    if (type === 'array' || (Array.isArray(type) && type.includes('array')) || 'items' in schema) {
+        return true;
+    }
+    return matchesComposedSchema(schema, isArraySchema);
+};
+/** Whether a resolved schema describes an object, including the OpenAPI 3.1 `type: ['object', 'null']` form. */
+export const isObjectSchema = (schema) => {
+    if (!schema) {
+        return false;
+    }
+    const type = schema.type;
+    if (type === 'object' || (Array.isArray(type) && type.includes('object')) || 'properties' in schema) {
+        return true;
+    }
+    return matchesComposedSchema(schema, isObjectSchema);
+};
+/**
+ * Collect the declared property names of an object schema, looking through `anyOf`/`oneOf`/`allOf`.
+ *
+ * `isObjectSchema` unwraps composed schemas (for example an optional object written as
+ * `anyOf: [{ type: 'object', properties: {…} }, { type: 'null' }]`), so property extraction has to do the
+ * same. Otherwise the names live on a subschema, the top level looks empty, and exploded `form` objects
+ * fall back to free-form gathering — claiming unrelated keys and failing `additionalProperties: false`.
+ */
+export const getObjectPropertyNames = (schema) => {
+    if (!schema) {
+        return [];
+    }
+    const names = new Set();
+    const properties = schema.properties;
+    if (properties && typeof properties === 'object') {
+        for (const key of Object.keys(properties)) {
+            names.add(key);
+        }
+    }
+    for (const keyword of ['anyOf', 'oneOf', 'allOf']) {
+        const subSchemas = schema[keyword];
+        if (Array.isArray(subSchemas)) {
+            for (const subSchema of subSchemas) {
+                if (subSchema && typeof subSchema === 'object') {
+                    for (const name of getObjectPropertyNames(subSchema)) {
+                        names.add(name);
+                    }
+                }
+            }
+        }
+    }
+    return [...names];
+};
+const wrap = (value) => (value === undefined ? undefined : [value]);
+// An empty value is an empty list, not a one-element list of the empty string. Otherwise `?ids=`
+// would satisfy a `minItems: 1` array while failing the element type check on `''`.
+const split = (value, delimiter) => value === undefined ? undefined : value === '' ? [] : value.split(delimiter);
+/**
+ * Build an exploded array from the repeated values (query) or the single value (other locations).
+ *
+ * A lone empty value (`?ids=`) is an empty array, not `['']`, matching the non-exploded `split`
+ * behaviour so an optional empty array is not rejected on its element type and `minItems` runs as
+ * intended. An explicitly repeated empty (`?ids=a&ids=`) keeps every element.
+ */
+const explodedArray = (single, multi) => {
+    const values = multi ?? wrap(single);
+    if (values === undefined) {
+        return undefined;
+    }
+    return values.length === 1 && values[0] === '' ? [] : values;
+};
+/** Drop a leading prefix (for example the `.` of `label` or the `;` of `matrix`) when present. */
+const stripPrefix = (value, prefix) => value.startsWith(prefix) ? value.slice(prefix.length) : value;
+/** Return the part of a `key=value` segment after the first `=`, or the whole segment when there is none. */
+const valueAfterEquals = (segment) => {
+    const equals = segment.indexOf('=');
+    return equals === -1 ? segment : segment.slice(equals + 1);
+};
+/** Split a `matrix`-encoded value into its `;`-separated segments, dropping the leading `;` and empties. */
+const matrixSegments = (value) => stripPrefix(value, ';')
+    .split(';')
+    .filter((segment) => segment.length > 0);
+/**
+ * Split a `label`-encoded value into its parts, dropping the leading `.`. Per the OpenAPI serialization
+ * rules a non-exploded `label` value is comma-separated (`.blue,black,brown`, `.R,100,G,200`) while an
+ * exploded one is dot-separated (`.blue.black.brown`, `.R=100.G=200`). An empty value means no parts.
+ */
+const labelParts = (value, explode) => {
+    const inner = stripPrefix(value, '.');
+    return inner === '' ? [] : inner.split(explode ? '.' : ',');
+};
+/** Build an object from a list of `key=value` segments (for example `['R=100', 'G=200']`). */
+const pairsFromList = (parts) => {
+    const result = {};
+    for (const part of parts) {
+        const equals = part.indexOf('=');
+        if (equals !== -1) {
+            result[part.slice(0, equals)] = part.slice(equals + 1);
+        }
+    }
+    return result;
+};
+/** Build an object from a flat list alternating key, value (for example `['R', '100', 'G', '200']`). */
+const alternatingFromList = (parts) => {
+    const result = {};
+    // Walk in pairs; a trailing key without a value is ignored.
+    for (let index = 0; index + 1 < parts.length; index += 2) {
+        const key = parts[index];
+        const propertyValue = parts[index + 1];
+        if (key !== undefined && propertyValue !== undefined) {
+            result[key] = propertyValue;
+        }
+    }
+    return result;
+};
+/**
+ * Deserialize a `matrix`-style array (path only). Non-exploded values join the elements after a single
+ * `;name=` prefix (`;ids=1,2,3`), while exploded values repeat the prefix per element (`;ids=1;ids=2`).
+ */
+const parseMatrixArray = (value, explode) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    const segments = matrixSegments(value);
+    if (explode) {
+        return segments.map(valueAfterEquals);
+    }
+    // Non-exploded: a single `name=a,b,c` segment whose value is comma-separated.
+    const [first] = segments;
+    return first === undefined ? [] : valueAfterEquals(first).split(',');
+};
+/**
+ * Deserialize a string-encoded array parameter into its elements.
+ *
+ * Returns `undefined` when the parameter is absent so the caller can enforce `required` separately.
+ * Object parameters (`deepObject`, simple/form objects) are not handled yet and are validated as-is.
+ */
+export const deserializeArrayParameter = ({ style, explode, single, multi, }) => {
+    switch (style) {
+        case 'spaceDelimited':
+            return explode ? explodedArray(single, multi) : split(single, ' ');
+        case 'pipeDelimited':
+            return explode ? explodedArray(single, multi) : split(single, '|');
+        case 'simple':
+            // Path and header arrays are comma-separated; `explode` does not change the delimiter. HTTP allows
+            // optional whitespace after the comma in header list values (`a, b, c`), so trim each element.
+            return single === undefined ? undefined : single === '' ? [] : single.split(',').map((element) => element.trim());
+        case 'label':
+            // Path `label` arrays are dot-prefixed. Non-exploded values are comma-separated (`.1,2,3`),
+            // exploded values are dot-separated (`.1.2.3`).
+            return single === undefined ? undefined : labelParts(single, explode);
+        case 'matrix':
+            return parseMatrixArray(single, explode);
+        default:
+            // `form` (and any unrecognised style): an exploded array repeats the key, otherwise it is comma-joined.
+            return explode ? explodedArray(single, multi) : split(single, ',');
+    }
+};
+/** Parse `R,100,G,200` (a flat list alternating key, value) into an object. */
+const parseAlternating = (value, delimiter) => value === undefined ? undefined : alternatingFromList(value.split(delimiter));
+/** Parse `R=100,G=200` (delimiter-separated `key=value` pairs) into an object. */
+const parsePairs = (value, delimiter) => value === undefined ? undefined : pairsFromList(value.split(delimiter));
+/** Parse `name[R]=100&name[G]=200` from the query map into an object. */
+const parseDeepObject = (query, name) => {
+    const prefix = `${name}[`;
+    const result = {};
+    for (const [key, value] of Object.entries(query)) {
+        if (!key.startsWith(prefix) || !key.endsWith(']')) {
+            continue;
+        }
+        const property = key.slice(prefix.length, -1);
+        // `deepObject` only defines a single level of nesting, so ignore keys like `name[a][b]` whose
+        // property still contains brackets rather than emitting a corrupt `a][b` property.
+        if (property.includes('[') || property.includes(']')) {
+            continue;
+        }
+        result[property] = value;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+};
+/**
+ * Deserialize a string-encoded object parameter into its properties, following the OpenAPI
+ * `style`/`explode` rules. Property values stay as strings so the caller can coerce them against the
+ * object's property schemas.
+ *
+ * Returns `undefined` when the parameter is absent so the caller can enforce `required` separately.
+ * Property values are strings, except for repeated query keys (an array-valued property such as
+ * `filter[tags]=a&filter[tags]=b`), which stay as a string array.
+ */
+export const deserializeObjectParameter = ({ style, explode, single, map, name, propertyNames, reservedKeys, }) => {
+    // `deepObject`: properties are encoded as bracketed query keys, e.g. `color[R]=100`.
+    if (style === 'deepObject') {
+        return map ? parseDeepObject(map, name) : undefined;
+    }
+    // Exploded `form`: each property is its own top-level key, e.g. `R=100&G=200` (one cookie per property
+    // for cookies). With declared properties we gather exactly those; a free-form object (no declared
+    // properties) claims every remaining key in the location, excluding keys owned by *other* declared
+    // parameters. Its own name stays claimable, so a property named like the parameter is not dropped.
+    if (style === 'form' && explode) {
+        if (!map) {
+            return undefined;
+        }
+        const keys = propertyNames?.length
+            ? propertyNames
+            : Object.keys(map).filter((key) => key === name || !reservedKeys?.has(key));
+        const result = {};
+        for (const property of keys) {
+            const value = map[property];
+            if (value !== undefined) {
+                result[property] = value;
+            }
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    // Exploded `simple` (path/header): comma-separated `key=value` pairs, e.g. `R=100,G=200`.
+    if (style === 'simple' && explode) {
+        return parsePairs(single, ',');
+    }
+    // `label` (path): dot-prefixed. Exploded uses dot-separated `key=value`, e.g. `.R=100.G=200`;
+    // non-exploded alternates comma-separated key and value, e.g. `.R,100,G,200`.
+    if (style === 'label') {
+        if (single === undefined) {
+            return undefined;
+        }
+        const parts = labelParts(single, explode);
+        return explode ? pairsFromList(parts) : alternatingFromList(parts);
+    }
+    // `matrix` (path): semicolon-prefixed. Exploded repeats `;key=value` per property, e.g. `;R=100;G=200`;
+    // non-exploded carries everything in one `;name=R,100,G,200` segment.
+    if (style === 'matrix') {
+        if (single === undefined) {
+            return undefined;
+        }
+        const segments = matrixSegments(single);
+        if (explode) {
+            return pairsFromList(segments);
+        }
+        const [first] = segments;
+        return first === undefined ? {} : alternatingFromList(valueAfterEquals(first).split(','));
+    }
+    // `spaceDelimited` / `pipeDelimited` (query): a flat alternating key,value list joined by the
+    // delimiter, e.g. `R 100 G 200` or `R|100|G|200`. Only defined for the non-exploded form.
+    if (style === 'spaceDelimited') {
+        return parseAlternating(single, ' ');
+    }
+    if (style === 'pipeDelimited') {
+        return parseAlternating(single, '|');
+    }
+    // Non-exploded `form` and `simple`: a flat list alternating key, value, e.g. `R,100,G,200`.
+    return parseAlternating(single, ',');
+};

package/dist/utils/find-preferred-response-key.d.ts

@@ -1,5 +1,18 @@
 /**
- * Find the preferred response key: default, 200, 201 …
+ * Find the preferred response key to mock.
+ *
+ * Preference order:
+ * 1. The lowest 2xx success response
+ * 2. The lowest non-informational code (3xx/4xx/5xx)
+ * 3. `default` — the catch-all for undeclared responses (typically an error)
+ * 4. An informational 1xx response, only when nothing else is defined
+ *
+ * Within each tier an explicit code wins over the range pattern that covers it (e.g. `200` over
+ * `2XX`), and range patterns are treated as their lowest member (e.g. `2XX` → `200`). `default`
+ * is the catch-all for codes not covered individually, so a defined success or error is preferred
+ * over it.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#responses-object
  */
 export declare function findPreferredResponseKey(responses?: string[]): string | undefined;
 //# sourceMappingURL=find-preferred-response-key.d.ts.map

package/dist/utils/find-preferred-response-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-preferred-response-key.d.ts","sourceRoot":"","sources":["../../src/utils/find-preferred-response-key.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,sBAQ5D"}
+{"version":3,"file":"find-preferred-response-key.d.ts","sourceRoot":"","sources":["../../src/utils/find-preferred-response-key.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAiBjF"}

package/dist/utils/find-preferred-response-key.js

@@ -1,11 +1,45 @@
+/** Matches an explicit HTTP status code (e.g. `200`) or a range pattern (e.g. `2XX`). */
+const STATUS_CODE_REGEX = /^[1-5](\d{2}|XX)$/i;
+/** Whether a status key is a range pattern (e.g. `2XX`) rather than an explicit code. */
+const isRange = (response) => /XX$/i.test(response);
+/** Whether a status key is an informational 1xx response. */
+const isInformational = (response) => response.startsWith('1');
+/** Whether a status key is a 2xx success response. */
+const isSuccess = (response) => response.startsWith('2');
+/** Turn a status key into a comparable number, treating a range like `2XX` as its lowest member (`200`). */
+const toComparableStatus = (response) => Number.parseInt(response.replace(/XX$/i, '00'), 10);
+const sortStatusCodes = (responses) => responses
+    .filter((response) => STATUS_CODE_REGEX.test(response))
+    .sort((left, right) => {
+    const difference = toComparableStatus(left) - toComparableStatus(right);
+    // On a tie, prefer an explicit code over a range pattern (e.g. `200` before `2XX`).
+    return difference !== 0 ? difference : Number(isRange(left)) - Number(isRange(right));
+});
 /**
- * Find the preferred response key: default, 200, 201 …
+ * Find the preferred response key to mock.
+ *
+ * Preference order:
+ * 1. The lowest 2xx success response
+ * 2. The lowest non-informational code (3xx/4xx/5xx)
+ * 3. `default` — the catch-all for undeclared responses (typically an error)
+ * 4. An informational 1xx response, only when nothing else is defined
+ *
+ * Within each tier an explicit code wins over the range pattern that covers it (e.g. `200` over
+ * `2XX`), and range patterns are treated as their lowest member (e.g. `2XX` → `200`). `default`
+ * is the catch-all for codes not covered individually, so a defined success or error is preferred
+ * over it.
+ *
+ * @see https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#responses-object
  */
 export function findPreferredResponseKey(responses) {
-    return (
-    // Regular status codes
-    ['default', '200', '201', '204', '404', '500'].find((key) => responses?.includes(key) ?? false) ??
-        // Lowest status code
-        responses?.sort()[0] ??
-        undefined);
+    if (!responses?.length) {
+        return undefined;
+    }
+    const statusCodes = sortStatusCodes(responses);
+    // Within a tier, prefer an explicit status code over the range pattern that covers it.
+    const byPreference = (predicate) => statusCodes.find((response) => predicate(response) && !isRange(response)) ?? statusCodes.find(predicate);
+    return (byPreference(isSuccess) ??
+        byPreference((response) => !isInformational(response)) ??
+        (responses.includes('default') ? 'default' : undefined) ??
+        byPreference(isInformational));
 }

package/dist/utils/generate-message.d.ts

@@ -0,0 +1,12 @@
+import type { MockMessage, ResolvedChannel } from '../transports/types.js';
+/**
+ * Generate an encoded mock frame for a channel message — the AsyncAPI analogue of the REST
+ * mocker's response generation. Prefers a defined example, otherwise generates a value from the
+ * message payload schema with the same `getExampleFromSchema` the HTTP mocker uses.
+ *
+ * @param channel - The resolved channel to mock a message for.
+ * @param messageId - Which message to emit; defaults to the channel's first message.
+ * @returns The encoded message, or `null` when the channel declares no messages.
+ */
+export declare function generateMessage(channel: ResolvedChannel, messageId?: string): MockMessage | null;
+//# sourceMappingURL=generate-message.d.ts.map

package/dist/utils/generate-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-message.d.ts","sourceRoot":"","sources":["../../src/utils/generate-message.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAmB,MAAM,oBAAoB,CAAA;AAWvF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAwBhG"}

package/dist/utils/generate-message.js

@@ -0,0 +1,41 @@
+import { getResolvedRefDeep } from '@scalar/workspace-store/helpers/get-resolved-ref-deep';
+import { getExampleFromSchema } from '@scalar/workspace-store/request-example';
+/** Encode a generated value to a wire string. Strings pass through; everything else is JSON. */
+function encode(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return JSON.stringify(value ?? null);
+}
+/**
+ * Generate an encoded mock frame for a channel message — the AsyncAPI analogue of the REST
+ * mocker's response generation. Prefers a defined example, otherwise generates a value from the
+ * message payload schema with the same `getExampleFromSchema` the HTTP mocker uses.
+ *
+ * @param channel - The resolved channel to mock a message for.
+ * @param messageId - Which message to emit; defaults to the channel's first message.
+ * @returns The encoded message, or `null` when the channel declares no messages.
+ */
+export function generateMessage(channel, messageId) {
+    const message = messageId
+        ? channel.messages.find((candidate) => candidate.id === messageId)
+        : channel.messages[0];
+    if (!message) {
+        return null;
+    }
+    let value = null;
+    if (message.examples.length > 0) {
+        // Prefer an explicit example, mirroring response-example selection in the REST mocker.
+        value = message.examples[0];
+    }
+    else if (message.payload) {
+        value = getExampleFromSchema(getResolvedRefDeep(message.payload), {
+            emptyString: 'string',
+            mode: 'read',
+        });
+    }
+    return {
+        data: encode(value),
+        event: message.id,
+    };
+}

package/dist/utils/normalize-response-body.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+type Schema = NonNullable<OpenAPIV3_1.ComponentsObject['schemas']>[string];
+export declare const normalizeResponseBody: (body: unknown, schema: Schema) => unknown;
+export {};
+//# sourceMappingURL=normalize-response-body.d.ts.map

package/dist/utils/normalize-response-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-response-body.d.ts","sourceRoot":"","sources":["../../src/utils/normalize-response-body.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,KAAK,MAAM,GAAG,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;AA0B1E,eAAO,MAAM,qBAAqB,GAAI,MAAM,OAAO,EAAE,QAAQ,MAAM,KAAG,OAMrE,CAAA"}

package/dist/utils/normalize-response-body.js

@@ -0,0 +1,25 @@
+import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
+const isArrayResponseSchema = (schema) => {
+    if (!schema) {
+        return false;
+    }
+    const resolvedSchema = getResolvedRef(schema);
+    if (!resolvedSchema || typeof resolvedSchema !== 'object') {
+        return false;
+    }
+    if ('type' in resolvedSchema) {
+        if (resolvedSchema.type === 'array') {
+            return true;
+        }
+        if (Array.isArray(resolvedSchema.type) && resolvedSchema.type.includes('array')) {
+            return true;
+        }
+    }
+    return 'items' in resolvedSchema;
+};
+export const normalizeResponseBody = (body, schema) => {
+    if (body === null || body === undefined || Array.isArray(body) || !isArrayResponseSchema(schema)) {
+        return body;
+    }
+    return [body];
+};

package/dist/utils/process-asyncapi-document.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncApiDocument } from '@scalar/types/asyncapi/3.1';
+/**
+ * Processes an AsyncAPI document by bundling external references and wrapping it so internal
+ * references stay intact but resolve lazily — the AsyncAPI counterpart of
+ * {@link processOpenApiDocument}.
+ *
+ * Unlike a full dereference, the returned document keeps `$ref` nodes in place. Consumers resolve
+ * them on demand with `getResolvedRef` from `@scalar/workspace-store`, which reads the `$ref-value`
+ * exposed by the magic proxy. This avoids eagerly flattening (and duplicating) the whole document.
+ *
+ * Only AsyncAPI 3.1 is supported; 2.x documents should be upgraded before being passed in.
+ *
+ * @param document - The AsyncAPI document to process. Can be a string (URL/path) or an object.
+ * @returns A promise that resolves to the AsyncAPI document with lazily resolvable references.
+ * @throws Error if the document cannot be processed or is invalid.
+ */
+export declare function processAsyncApiDocument(document: string | Record<string, any> | undefined): Promise<AsyncApiDocument>;
+/**
+ * Detects whether a loaded document describes an AsyncAPI API (rather than OpenAPI/Swagger).
+ * Used to route an incoming document to the right mock engine.
+ */
+export declare function isAsyncApiDocument(document: unknown): boolean;
+//# sourceMappingURL=process-asyncapi-document.d.ts.map

package/dist/utils/process-asyncapi-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-asyncapi-document.d.ts","sourceRoot":"","sources":["../../src/utils/process-asyncapi-document.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GACjD,OAAO,CAAC,gBAAgB,CAAC,CAiC3B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAE7D"}

package/dist/utils/process-asyncapi-document.js

@@ -0,0 +1,56 @@
+import { bundle } from '@scalar/json-magic/bundle';
+import { fetchUrls, parseJson, parseYaml, readFiles } from '@scalar/json-magic/bundle/plugins/node';
+import { createMagicProxy } from '@scalar/json-magic/magic-proxy';
+/**
+ * Processes an AsyncAPI document by bundling external references and wrapping it so internal
+ * references stay intact but resolve lazily — the AsyncAPI counterpart of
+ * {@link processOpenApiDocument}.
+ *
+ * Unlike a full dereference, the returned document keeps `$ref` nodes in place. Consumers resolve
+ * them on demand with `getResolvedRef` from `@scalar/workspace-store`, which reads the `$ref-value`
+ * exposed by the magic proxy. This avoids eagerly flattening (and duplicating) the whole document.
+ *
+ * Only AsyncAPI 3.1 is supported; 2.x documents should be upgraded before being passed in.
+ *
+ * @param document - The AsyncAPI document to process. Can be a string (URL/path) or an object.
+ * @returns A promise that resolves to the AsyncAPI document with lazily resolvable references.
+ * @throws Error if the document cannot be processed or is invalid.
+ */
+export async function processAsyncApiDocument(document) {
+    // Handle empty/undefined input gracefully with a minimal valid document.
+    if (!document || (typeof document === 'object' && Object.keys(document).length === 0)) {
+        return {
+            asyncapi: '3.1.0',
+            info: {
+                title: 'Mock API',
+                version: '1.0.0',
+            },
+            channels: {},
+            operations: {},
+        };
+    }
+    let bundled;
+    try {
+        // Bundle external references; parse string inputs (JSON or YAML) along the way.
+        bundled = await bundle(document, {
+            plugins: [parseJson(), parseYaml(), readFiles(), fetchUrls()],
+            treeShake: false,
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to bundle AsyncAPI document: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!bundled || typeof bundled !== 'object') {
+        throw new Error('Bundled document is invalid: expected an object');
+    }
+    // Wrap the document in a magic proxy so internal references resolve lazily via `$ref-value`.
+    // External references were already pulled inline by `bundle` above, so only local `$ref`s remain.
+    return createMagicProxy(bundled);
+}
+/**
+ * Detects whether a loaded document describes an AsyncAPI API (rather than OpenAPI/Swagger).
+ * Used to route an incoming document to the right mock engine.
+ */
+export function isAsyncApiDocument(document) {
+    return typeof document === 'object' && document !== null && 'asyncapi' in document;
+}

package/dist/utils/resolve-channels.d.ts

@@ -0,0 +1,11 @@
+import type { AsyncApiDocument } from '@scalar/types/asyncapi/3.1';
+import type { ResolvedChannel } from '../transports/types.js';
+/**
+ * Normalize an AsyncAPI 3.1 document into a flat list of {@link ResolvedChannel}s a transport can
+ * serve. Channel, message, operation, and server resolution are delegated to
+ * `@scalar/workspace-store/channel-example` — the same layer the API client uses to connect to
+ * channels — so the mock and the client agree on how a document maps to channels and operations
+ * (including operation traits). This function only adapts that output into the transport types.
+ */
+export declare function resolveChannels(document: AsyncApiDocument): ResolvedChannel[];
+//# sourceMappingURL=resolve-channels.d.ts.map

package/dist/utils/resolve-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-channels.d.ts","sourceRoot":"","sources":["../../src/utils/resolve-channels.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAA;AAWzF,OAAO,KAAK,EAAE,eAAe,EAAsC,MAAM,oBAAoB,CAAA;AAkE7F;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,GAAG,eAAe,EAAE,CA6C7E"}