@scalar/workspace-store 0.68.1 → 0.68.3

package/dist/helpers/resolve-form-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-form-schema.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-form-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAMxE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,oBAAoB,GAAG,SAAS,EACxC,uBAAuB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC5C,YAAY,GAAG,SAyJjB,CAAA"}

package/dist/helpers/resolve-form-schema.js

@@ -0,0 +1,143 @@
+import { objectEntries } from '@scalar/helpers/object/object-entries';
+import { selectExampleComposition } from '../request-example/builder/helpers/get-example-from-schema.js';
+import { resolve } from '../resolve.js';
+import { isNumberSchema, isObjectSchema } from '../schemas/v3.2/strict/type-guards.js';
+import { getSchemaAnnotations, resolveSchemaWithAnnotations } from './resolve-schema-with-annotations.js';
+import { unpackProxyShallow } from './unpack-proxy.js';
+/**
+ * Expose the selected request-body shape to form editors and serializers without changing the
+ * API description. Use the example generator's branch selection so field types match its values.
+ * Unselected alternatives remain on the view for validation, but do not contribute form fields.
+ */
+export const resolveFormSchema = (schema, compositionSelection) => {
+    const ancestors = new Set();
+    const visit = (input, path, selection) => {
+        const source = resolve.schema(input);
+        const resolved = resolveSchemaWithAnnotations(input);
+        if (!source || !resolved || !input) {
+            return resolved;
+        }
+        const identity = unpackProxyShallow(input);
+        // Recursive properties remain opaque leaves instead of expanding an infinite form.
+        if (ancestors.has(identity)) {
+            return isObjectSchema(resolved) ? { ...resolved, properties: undefined } : resolved;
+        }
+        ancestors.add(identity);
+        try {
+            if (source.allOf?.length) {
+                let choiceIndex = 0;
+                const members = source.allOf.map((member) => {
+                    const memberSchema = resolve.schema(member);
+                    const isChoice = Boolean(memberSchema?.oneOf || memberSchema?.anyOf);
+                    return visit(member, isChoice ? [...path, String(choiceIndex++)] : path, selection) ?? member;
+                });
+                if (!resolved.allOf) {
+                    return resolveSchemaWithAnnotations({ ...source, allOf: members });
+                }
+                const { allOf: _allOf, ...siblings } = source;
+                const parts = [visit(siblings, path, selection), ...members].filter((member) => member !== undefined);
+                const typed = parts.filter((member) => 'type' in member && member.type !== undefined);
+                const first = typed[0];
+                if (!first || !('type' in first) || Array.isArray(first.type)) {
+                    return resolved;
+                }
+                const type = typed.some((member) => 'type' in member && member.type === 'integer') &&
+                    (first.type === 'integer' || first.type === 'number')
+                    ? 'integer'
+                    : first.type;
+                // Incompatible intersections have no single input type. Keep them as opaque leaves.
+                if (typed.some((member) => 'type' in member && member.type !== type && !(type === 'integer' && member.type === 'number'))) {
+                    return resolved;
+                }
+                const annotations = Object.assign({}, ...parts.map(getSchemaAnnotations));
+                const result = { ...first, ...annotations, ...siblings, type, allOf: source.allOf };
+                Reflect.deleteProperty(result, '__scalar_');
+                if (isObjectSchema(result)) {
+                    const properties = {};
+                    const required = new Set();
+                    for (const part of parts) {
+                        if ('required' in part) {
+                            for (const name of part.required ?? []) {
+                                required.add(name);
+                            }
+                        }
+                        if ('properties' in part) {
+                            for (const [name, child] of objectEntries(part.properties ?? {})) {
+                                const previous = properties[name];
+                                properties[name] = previous
+                                    ? (visit({ __scalar_: '', allOf: [previous, child] }, [...path, name], selection) ?? child)
+                                    : child;
+                            }
+                        }
+                    }
+                    result.properties = properties;
+                    result.required = [...required];
+                }
+                if (isNumberSchema(result)) {
+                    const minima = parts.flatMap((part) => 'minimum' in part && part.minimum !== undefined ? [part.minimum] : []);
+                    const maxima = parts.flatMap((part) => 'maximum' in part && part.maximum !== undefined ? [part.maximum] : []);
+                    if (minima.length) {
+                        result.minimum = Math.max(...minima);
+                    }
+                    if (maxima.length) {
+                        result.maximum = Math.min(...maxima);
+                    }
+                }
+                return result;
+            }
+            const properties = isObjectSchema(resolved) && resolved.properties
+                ? Object.fromEntries(objectEntries(resolved.properties).map(([key, child]) => [
+                    key,
+                    visit(child, [...path, key], selection) ?? child,
+                ]))
+                : undefined;
+            const base = properties ? { ...resolved, properties } : resolved;
+            const keyword = resolved.oneOf ? 'oneOf' : 'anyOf';
+            const candidate = selectExampleComposition(resolved, path, { compositionSelection: selection });
+            if (!candidate) {
+                return base;
+            }
+            const selectionKey = [...path, keyword].join('.');
+            const { [selectionKey]: _selection, ...remainingSelection } = selection ?? {};
+            const selected = visit(candidate, path, remainingSelection);
+            if (!selected) {
+                return base;
+            }
+            const result = { ...base, ...selected, [keyword]: resolved[keyword] };
+            if ('type' in result) {
+                Reflect.deleteProperty(result, '__scalar_');
+            }
+            if (isNumberSchema(result)) {
+                // Parent and branch bounds both apply; selecting a variant must not weaken validation.
+                if ('minimum' in base &&
+                    'minimum' in selected &&
+                    base.minimum !== undefined &&
+                    selected.minimum !== undefined) {
+                    result.minimum = Math.max(base.minimum, selected.minimum);
+                }
+                if ('maximum' in base &&
+                    'maximum' in selected &&
+                    base.maximum !== undefined &&
+                    selected.maximum !== undefined) {
+                    result.maximum = Math.min(base.maximum, selected.maximum);
+                }
+            }
+            if (resolved.description !== undefined) {
+                result.description = resolved.description;
+            }
+            if (isObjectSchema(result)) {
+                const baseProperties = 'properties' in base ? base.properties : undefined;
+                const selectedProperties = 'properties' in selected ? selected.properties : undefined;
+                const baseRequired = 'required' in base ? base.required : undefined;
+                const selectedRequired = 'required' in selected ? selected.required : undefined;
+                result.properties = { ...baseProperties, ...selectedProperties };
+                result.required = [...new Set([...(baseRequired ?? []), ...(selectedRequired ?? [])])];
+            }
+            return result;
+        }
+        finally {
+            ancestors.delete(identity);
+        }
+    };
+    return visit(schema, ['requestBody'], compositionSelection);
+};

package/dist/helpers/resolve-schema-with-annotations.d.ts

@@ -0,0 +1,11 @@
+import type { SchemaObject } from '../schemas/v3.2/strict/openapi-document.js';
+import type { MaybeRefSchemaObject } from '../schemas/v3.2/strict/schema.js';
+/** Extract annotation keywords without copying validation constraints into a form projection. */
+export declare const getSchemaAnnotations: (schema: SchemaObject) => Record<string, unknown>;
+/**
+ * Expose the value schema inside an annotation-only allOf wrapper for form editors and serializers.
+ * Multiple value schemas retain their composition, since combining their constraints requires more
+ * than spreading their keywords. The returned view does not mutate the API description.
+ */
+export declare const resolveSchemaWithAnnotations: (schema: MaybeRefSchemaObject | undefined) => SchemaObject | undefined;
+//# sourceMappingURL=resolve-schema-with-annotations.d.ts.map

package/dist/helpers/resolve-schema-with-annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-schema-with-annotations.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-schema-with-annotations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAA;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAmBxE,iGAAiG;AACjG,eAAO,MAAM,oBAAoB,GAAI,QAAQ,YAAY,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CACK,CAAA;AAEvF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ,oBAAoB,GAAG,SAAS,KAAG,YAAY,GAAG,SAuCtG,CAAA"}

package/dist/helpers/resolve-schema-with-annotations.js

@@ -0,0 +1,57 @@
+import { resolve } from '../resolve.js';
+import { unpackProxyShallow } from './unpack-proxy.js';
+const annotationKeys = new Set([
+    'title',
+    'description',
+    'default',
+    'examples',
+    'example',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+    '$comment',
+    'externalDocs',
+    // TypeBox marks schemas without an explicit type; this does not constrain their value.
+    '__scalar_',
+]);
+/** Extract annotation keywords without copying validation constraints into a form projection. */
+export const getSchemaAnnotations = (schema) => Object.fromEntries(Object.entries(schema).filter(([key]) => annotationKeys.has(key)));
+/**
+ * Expose the value schema inside an annotation-only allOf wrapper for form editors and serializers.
+ * Multiple value schemas retain their composition, since combining their constraints requires more
+ * than spreading their keywords. The returned view does not mutate the API description.
+ */
+export const resolveSchemaWithAnnotations = (schema) => {
+    const seen = new Set();
+    const visit = (input) => {
+        const resolved = resolve.schema(input);
+        if (!resolved?.allOf?.length || !input) {
+            return resolved;
+        }
+        if (Object.keys(resolved).some((key) => key !== 'allOf' && key !== '$ref' && !annotationKeys.has(key))) {
+            return resolved;
+        }
+        const identity = unpackProxyShallow(input);
+        if (seen.has(identity)) {
+            return resolved;
+        }
+        seen.add(identity);
+        const members = resolved.allOf.map((member) => resolve.schema(member));
+        if (members.some((member) => !member)) {
+            return resolved;
+        }
+        const valueMembers = members.filter((member) => member && Object.keys(member).some((key) => !annotationKeys.has(key)));
+        const valueMember = valueMembers[0];
+        if (valueMembers.length !== 1 || !valueMember) {
+            return resolved;
+        }
+        const valueIndex = members.indexOf(valueMember);
+        const valueSchema = visit(resolved.allOf[valueIndex]);
+        const annotations = Object.assign({}, ...members.filter((member) => member !== valueMember && member !== undefined).map(getSchemaAnnotations));
+        const { allOf: _allOf, ...siblings } = resolved;
+        const result = { ...valueSchema, ...annotations, ...siblings };
+        Reflect.deleteProperty(result, '__scalar_');
+        return result;
+    };
+    return visit(schema);
+};

package/dist/helpers/resolve-security-requirements.d.ts

@@ -0,0 +1,15 @@
+import { type LoaderPlugin } from '@scalar/json-magic/bundle';
+type SecurityUriOptions = {
+    origin?: string;
+    loaders: LoaderPlugin[];
+};
+/**
+ * Makes URI requirements available to the existing name-based auth consumers.
+ * Aliases live only in the working document; export removes them and restores authored keys.
+ * Relative keys in referenced documents become absolute to keep distinct document bases apart.
+ */
+export declare const resolveSecurityRequirements: (document: Record<string, unknown>, { origin, loaders }: SecurityUriOptions) => Promise<void>;
+/** Remove runtime URI aliases while keeping edited scopes and authored requirement spellings. */
+export declare const restoreSecurityRequirements: (document: Record<string, unknown>) => void;
+export {};
+//# sourceMappingURL=resolve-security-requirements.d.ts.map

package/dist/helpers/resolve-security-requirements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-security-requirements.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-security-requirements.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,YAAY,EAAgC,MAAM,2BAA2B,CAAA;AAa3F,KAAK,kBAAkB,GAAG;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,YAAY,EAAE,CAAA;CACxB,CAAA;AAUD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,qBAA2B,kBAAkB,KAC5C,OAAO,CAAC,IAAI,CAoKd,CAAA;AAED,iGAAiG;AACjG,eAAO,MAAM,2BAA2B,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAkE/E,CAAA"}

package/dist/helpers/resolve-security-requirements.js

@@ -0,0 +1,241 @@
+import { isHttpMethod } from '@scalar/helpers/http/is-http-method';
+import { isObject } from '@scalar/helpers/object/is-object';
+import { isPollutionKey } from '@scalar/helpers/object/prevent-pollution';
+import { isSchemaPath } from '@scalar/helpers/openapi/is-schema-path';
+import { bundle, resolveReferencePath } from '@scalar/json-magic/bundle';
+import { createMagicProxy } from '@scalar/json-magic/magic-proxy';
+import { Value } from '@scalar/typebox/value';
+import { generateUniqueValue } from '../helpers/generate-unique-value.js';
+import { getResolvedRef } from '../helpers/get-resolved-ref.js';
+import { normalizeAuthSchemes } from '../plugins/bundler/index.js';
+import { resolveOpenApiDocument } from '../plugins/bundler/openapi-document.js';
+import { SecuritySchemeObjectSchema } from '../schemas/v3.2/strict/openapi-document.js';
+const ALIASES = 'x-scalar-security-uri-aliases';
+const ORIGINAL_KEYS = 'x-scalar-original-security-keys';
+/** Resolve the URI portion separately so filesystem origins do not interpret fragments as filenames. */
+const absoluteReference = (reference, base) => {
+    const separator = reference.indexOf('#');
+    const resource = separator === -1 ? reference : reference.slice(0, separator);
+    const fragment = separator === -1 ? '' : reference.slice(separator);
+    return `${resource ? resolveReferencePath(base, resource) : base}${fragment}`;
+};
+/**
+ * Makes URI requirements available to the existing name-based auth consumers.
+ * Aliases live only in the working document; export removes them and restores authored keys.
+ * Relative keys in referenced documents become absolute to keep distinct document bases apart.
+ */
+export const resolveSecurityRequirements = async (document, { origin = '/', loaders }) => {
+    if (typeof document.openapi !== 'string' || !/^3\.2\.\d+$/.test(document.openapi)) {
+        return;
+    }
+    const originalKeys = isObject(document[ORIGINAL_KEYS]) ? document[ORIGINAL_KEYS] : {};
+    const components = isObject(document.components) ? document.components : {};
+    const schemes = isObject(components.securitySchemes) ? components.securitySchemes : {};
+    const metadata = isObject(document[ALIASES])
+        ? document[ALIASES]
+        : {
+            hadComponents: isObject(document.components),
+            hadSecuritySchemes: isObject(components.securitySchemes),
+            schemes: {},
+        };
+    const aliases = isObject(metadata.schemes) ? metadata.schemes : {};
+    metadata.schemes = aliases;
+    const namedSchemes = new Set(Object.keys(schemes).filter((name) => !Object.hasOwn(aliases, name)));
+    const visited = new WeakSet();
+    const processedDocuments = new Set();
+    const cache = new Map();
+    const visit = async (node, path, base, external) => {
+        if (node === null || typeof node !== 'object' || visited.has(node) || isSchemaPath(path)) {
+            return;
+        }
+        visited.add(node);
+        // Security is a fixed field on document and operation objects, not arbitrary example payloads.
+        const operationKey = path.at(-1) ?? '';
+        const isOperation = isHttpMethod(operationKey) || path.at(-2) === 'additionalOperations';
+        const isDocument = path.length === 0 || (path[0] === 'x-ext' && path.length === 2);
+        if (isObject(node) && (isDocument || isOperation) && Array.isArray(node.security)) {
+            for (const [index, requirement] of node.security.entries()) {
+                if (!isObject(requirement)) {
+                    continue;
+                }
+                for (const [name, scopes] of Object.entries(requirement)) {
+                    if (namedSchemes.has(name) || !Array.isArray(scopes)) {
+                        continue;
+                    }
+                    const uri = (() => {
+                        try {
+                            return Object.hasOwn(aliases, name) && typeof aliases[name] === 'string'
+                                ? aliases[name]
+                                : absoluteReference(name, base);
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    })();
+                    if (uri === undefined) {
+                        continue;
+                    }
+                    const key = await generateUniqueValue({
+                        defaultValue: external ? uri : name,
+                        validation: (candidate) => !namedSchemes.has(candidate) &&
+                            (!Object.hasOwn(aliases, candidate) || aliases[candidate] === uri) &&
+                            (!external || candidate === name || !Object.hasOwn(requirement, candidate)),
+                        maxRetries: Object.keys(schemes).length + 1,
+                    });
+                    if (key === undefined) {
+                        continue;
+                    }
+                    if (!Object.hasOwn(aliases, key)) {
+                        const reference = { $ref: uri };
+                        await bundle({ components: { securitySchemes: { target: reference } } }, {
+                            root: document,
+                            origin,
+                            treeShake: false,
+                            urlMap: true,
+                            cache,
+                            plugins: [...loaders, normalizeAuthSchemes()],
+                            hooks: { resolveDocument: resolveOpenApiDocument },
+                        });
+                        // Validate the target before exposing an auth option; missing pointers and non-schemes
+                        // keep their original requirement and never acquire a misleading working alias.
+                        const proxy = createMagicProxy({ ...document, 'x-scalar-security-uri-target': reference }, {
+                            documentUri: resolveOpenApiDocument(document, origin)?.baseUri,
+                        });
+                        const target = getResolvedRef(proxy['x-scalar-security-uri-target']);
+                        // The strict runtime schema requires refreshUrl, while authored OAuth flows may omit it.
+                        const validationTarget = isObject(target) && target.type === 'oauth2' && isObject(target.flows)
+                            ? {
+                                ...target,
+                                flows: Object.fromEntries(Object.entries(target.flows).map(([flow, value]) => [
+                                    flow,
+                                    isObject(value) ? { refreshUrl: '', ...value } : value,
+                                ])),
+                            }
+                            : target;
+                        if (!Value.Check(SecuritySchemeObjectSchema, validationTarget)) {
+                            continue;
+                        }
+                        Object.defineProperty(schemes, key, {
+                            value: reference,
+                            enumerable: true,
+                            writable: true,
+                            configurable: true,
+                        });
+                        Object.defineProperty(aliases, key, { value: uri, enumerable: true, writable: true, configurable: true });
+                        components.securitySchemes = schemes;
+                        document.components = components;
+                        document[ALIASES] = metadata;
+                    }
+                    if (external) {
+                        const location = JSON.stringify([...path, 'security', String(index)]);
+                        const mapping = isObject(originalKeys[location]) ? originalKeys[location] : {};
+                        Object.defineProperty(mapping, name, { value: key, enumerable: true, writable: true, configurable: true });
+                        originalKeys[location] = mapping;
+                        document[ORIGINAL_KEYS] = originalKeys;
+                        if (key === name) {
+                            continue;
+                        }
+                        const previous = Object.hasOwn(requirement, key) ? requirement[key] : [];
+                        Object.defineProperty(requirement, key, {
+                            value: [...new Set([...(Array.isArray(previous) ? previous : []), ...scopes])],
+                            enumerable: true,
+                            writable: true,
+                            configurable: true,
+                        });
+                        delete requirement[name];
+                    }
+                }
+            }
+        }
+        for (const [key, child] of Object.entries(node)) {
+            if (key.startsWith('x-') || key === 'example' || key === 'examples' || key === 'security') {
+                continue;
+            }
+            await visit(child, [...path, key], base, external);
+        }
+    };
+    const entryBase = resolveOpenApiDocument(document, origin)?.baseUri ?? origin;
+    await visit(document, [], entryBase, false);
+    // URI-only dependencies can load further documents, so process newly embedded documents too.
+    while (isObject(document['x-ext'])) {
+        const next = Object.entries(document['x-ext']).find(([key]) => !processedDocuments.has(key));
+        if (!next) {
+            break;
+        }
+        const [key, external] = next;
+        processedDocuments.add(key);
+        if (!isObject(external)) {
+            continue;
+        }
+        if (typeof external.openapi === 'string' && !/^3\.2\.\d+$/.test(external.openapi)) {
+            continue;
+        }
+        const mappings = document['x-ext-urls'];
+        const retrieval = isObject(mappings) && typeof mappings[key] === 'string' ? mappings[key] : key;
+        const retrievalUri = resolveReferencePath(entryBase, retrieval);
+        await visit(external, ['x-ext', key], resolveOpenApiDocument(external, retrievalUri)?.baseUri ?? retrievalUri, true);
+    }
+};
+/** Remove runtime URI aliases while keeping edited scopes and authored requirement spellings. */
+export const restoreSecurityRequirements = (document) => {
+    const originalKeys = Object.hasOwn(document, ORIGINAL_KEYS) ? document[ORIGINAL_KEYS] : undefined;
+    if (isObject(originalKeys)) {
+        for (const [location, mapping] of Object.entries(originalKeys)) {
+            const path = (() => {
+                try {
+                    return JSON.parse(location);
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            if (!Array.isArray(path) ||
+                !path.every((segment) => typeof segment === 'string' && !isPollutionKey(segment)) ||
+                !isObject(mapping)) {
+                continue;
+            }
+            const requirement = path.reduce((parent, segment) => {
+                if (parent === null || typeof parent !== 'object' || !Object.hasOwn(parent, segment)) {
+                    return undefined;
+                }
+                return Reflect.get(parent, segment);
+            }, document);
+            if (!isObject(requirement)) {
+                continue;
+            }
+            const entries = Object.entries(mapping).flatMap(([original, rewritten]) => typeof rewritten === 'string' && Object.hasOwn(requirement, rewritten)
+                ? [{ original, rewritten, scopes: requirement[rewritten] }]
+                : []);
+            for (const { rewritten } of entries) {
+                delete requirement[rewritten];
+            }
+            for (const { original, scopes } of entries) {
+                Object.defineProperty(requirement, original, {
+                    value: scopes,
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+        }
+    }
+    const metadata = Object.hasOwn(document, ALIASES) ? document[ALIASES] : undefined;
+    const components = Object.hasOwn(document, 'components') ? document.components : undefined;
+    if (isObject(metadata) &&
+        isObject(metadata.schemes) &&
+        isObject(components) &&
+        Object.hasOwn(components, 'securitySchemes') &&
+        isObject(components.securitySchemes)) {
+        for (const key of Object.keys(metadata.schemes)) {
+            delete components.securitySchemes[key];
+        }
+        if (!metadata.hadSecuritySchemes && Object.keys(components.securitySchemes).length === 0) {
+            delete components.securitySchemes;
+        }
+        if (!metadata.hadComponents && Object.keys(components).length === 0) {
+            delete document.components;
+        }
+    }
+    delete document[ALIASES];
+    delete document[ORIGINAL_KEYS];
+};

package/dist/helpers/resolve-traits.d.ts

@@ -0,0 +1,3 @@
+/** Merge traits in order, then apply the target's own fields with highest priority. */
+export declare const resolveTraits: <T extends object>(target: T, traits: readonly object[]) => T;
+//# sourceMappingURL=resolve-traits.d.ts.map

package/dist/helpers/resolve-traits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-traits.d.ts","sourceRoot":"","sources":["../../src/helpers/resolve-traits.ts"],"names":[],"mappings":"AAoEA,uFAAuF;AACvF,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,SAAS,MAAM,EAAE,KAAG,CAetF,CAAA"}

package/dist/helpers/resolve-traits.js

@@ -0,0 +1,68 @@
+import { isObject } from '@scalar/helpers/object/is-object';
+import { getResolvedRef } from './get-resolved-ref.js';
+const schemaMaps = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas']);
+const dataFields = new Set(['example', 'examples', 'default', 'enum', 'const', 'value', 'dataValue']);
+/**
+ * Apply JSON Merge Patch to resolved trait fields. Unlike mergeObjects, null removes a key.
+ * Resolve schema references before merging so a message can extend referenced trait headers.
+ */
+const mergeTraitFields = (target, patch, context = 'object', ancestors = new WeakMap()) => {
+    // Reply channels identify a location in the document, so retain their reference wrappers.
+    if (context === 'reference') {
+        return patch;
+    }
+    const resolvedPatch = context === 'object' && isObject(patch) && typeof patch.$ref === 'string' ? getResolvedRef(patch) : patch;
+    if (!isObject(resolvedPatch)) {
+        return resolvedPatch;
+    }
+    // Resolved schemas can be recursive. Keep their cycles without changing the source document.
+    if (ancestors.has(resolvedPatch)) {
+        return ancestors.get(resolvedPatch);
+    }
+    const resolvedTarget = context === 'object' && isObject(target) && typeof target.$ref === 'string' ? getResolvedRef(target) : target;
+    const result = isObject(resolvedTarget) ? { ...resolvedTarget } : {};
+    ancestors.set(resolvedPatch, result);
+    for (const [key, value] of Object.entries(resolvedPatch)) {
+        if (value === null) {
+            delete result[key];
+        }
+        else if (value !== undefined) {
+            // Schema names and example data can contain literal $ref keys without being references.
+            const childContext = context === 'data'
+                ? 'data'
+                : context === 'map'
+                    ? 'object'
+                    : key === 'channel'
+                        ? 'reference'
+                        : dataFields.has(key) || key.startsWith('x-')
+                            ? 'data'
+                            : schemaMaps.has(key)
+                                ? 'map'
+                                : 'object';
+            // Define an own property even for schema properties named __proto__.
+            Object.defineProperty(result, key, {
+                value: mergeTraitFields(Object.hasOwn(result, key) ? result[key] : undefined, value, childContext, ancestors),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+    ancestors.delete(resolvedPatch);
+    return result;
+};
+/** Merge traits in order, then apply the target's own fields with highest priority. */
+export const resolveTraits = (target, traits) => {
+    if (traits.length === 0) {
+        return target;
+    }
+    const inherited = traits.reduce((fields, trait) => {
+        const resolved = getResolvedRef(trait);
+        return resolved ? mergeTraitFields(fields, resolved) : fields;
+    }, {});
+    // Only overlay fields supplied by traits. Unrelated fields keep their references and identity.
+    const overrides = Object.fromEntries(Object.entries(target).filter(([key]) => Object.hasOwn(inherited, key)));
+    const merged = mergeTraitFields(inherited, overrides);
+    const ownFields = Object.fromEntries(Object.entries(target).filter(([key]) => !Object.hasOwn(inherited, key)));
+    return { ...ownFields, ...merged };
+};

package/dist/helpers/serialize-stream-example.js

@@ -11,7 +11,7 @@ export const serializeStreamExample = (value, contentType, singleItem) => {
         return undefined;
     }
     const format = getStreamFormat(contentType);
-    const items = singleItem ? [value] : Array.isArray(value) ? value : [value];
+    const items = !singleItem && Array.isArray(value) ? value : [value];
     if (format === 'json-lines') {
         return items.map((item) => `${JSON.stringify(item)}\n`).join('');
     }

package/dist/helpers/use-external-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-external-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/use-external-examples.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAEZ,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,6BAA6B,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAE3E,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,MAAM,uBAAuB,CAA+B,CAAA;AAEzG,0GAA0G;AAC1G,eAAO,MAAM,oBAAoB,GAAI,QAAQ,GAAG,CAAC,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAAC,KAAG,GAAG,CAAC,OAAO,CAuBvG,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAC7C,UAAS,MAAM,OAAoB,EACnC,WAAW,MAAM,uBAAuB,KACvC;IACD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,CAAA;IAC1E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAsC3B,CAAA"}
+{"version":3,"file":"use-external-examples.d.ts","sourceRoot":"","sources":["../../src/helpers/use-external-examples.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EAOT,MAAM,KAAK,CAAA;AAEZ,OAAO,EAAE,KAAK,uBAAuB,EAAiC,MAAM,6BAA6B,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAA;AAE3E,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,MAAM,uBAAuB,CAA+B,CAAA;AAEzG,0GAA0G;AAC1G,eAAO,MAAM,oBAAoB,GAAI,QAAQ,GAAG,CAAC,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAAC,KAAG,GAAG,CAAC,OAAO,CAyBvG,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EAC7C,UAAS,MAAM,OAAoB,EACnC,WAAW,MAAM,uBAAuB,KACvC;IACD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,KAAK,aAAa,GAAG,SAAS,CAAA;IAC1E,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CA8C3B,CAAA"}

package/dist/helpers/use-external-examples.js

@@ -10,8 +10,9 @@ export const useExampleVisibility = (target) => {
         observer?.disconnect();
         visible.value = false;
         const node = element && ('$el' in element ? element.$el : element);
-        if (typeof Element === 'undefined' || !(node instanceof Element))
+        if (typeof Element === 'undefined' || !(node instanceof Element)) {
             return;
+        }
         if (typeof IntersectionObserver === 'undefined') {
             visible.value = true;
             return;
@@ -32,22 +33,26 @@ export const useExternalExamples = (examples, enabled = () => true, resolver) =>
         .filter((example) => example !== undefined && example.value === undefined && !!example.externalValue)
         .map((example) => getResolver()(example)));
     watchEffect(() => {
-        if (!enabled())
+        if (!enabled()) {
             return;
+        }
         for (const state of states.value) {
-            if (state.status === 'idle')
+            if (state.status === 'idle') {
                 void state.load();
+            }
         }
     });
     return {
         pending: computed(() => states.value.some((state) => state.status !== 'loaded')),
         failed: computed(() => states.value.some((state) => state.status === 'error')),
         resolve: (example) => {
-            if (!example || example.value !== undefined || !example.externalValue)
+            if (!example || example.value !== undefined || !example.externalValue) {
                 return example;
+            }
             const state = getResolver()(example);
-            if (state.status !== 'loaded')
+            if (state.status !== 'loaded') {
                 return example;
+            }
             // A 3.2 example can pair structured data with external wire text. Keep both in the
             // resolved view so raw consumers display the download and form editors retain the data.
             if (example.dataValue !== undefined && state.serializedValue !== undefined) {

package/dist/mutators/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAU3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SA0EvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAoFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;yCAEnD,UAAU,CAAC,mCAAmC,CAAC;0CAE9C,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAU3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAqED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SA0EvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAsFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;yCAEnD,UAAU,CAAC,mCAAmC,CAAC;0CAE9C,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}

package/dist/mutators/auth.js

@@ -590,8 +590,9 @@ export const deleteSecurityScheme = (store, document, { names }) => {
         forEachPathItemOperation(pathItemRef, (method, operationRef) => {
             // Get mutable reference for the operation (could resolve $ref proxies)
             const resolvedOperation = getResolvedRef(operationRef);
-            if (!resolvedOperation)
+            if (!resolvedOperation) {
                 return;
+            }
             // Remove from operation-level security array
             if ('security' in resolvedOperation && resolvedOperation['security']) {
                 resolvedOperation['security'] = filterSecuritySchemes(resolvedOperation['security']);

package/dist/mutators/operation/helpers/har-to-operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eA0HxB,CAAA"}
+{"version":3,"file":"har-to-operation.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/har-to-operation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,8DAA8D,CAAA;AAKpH,KAAK,mBAAmB,GAAG;IACzB,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAA;IACtB,oEAAoE;IACpE,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,eAAe,CAAA;IAC/B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACvC,CAAA;AAyBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,2DAK5B,mBAAmB,KAAG,eA4HxB,CAAA"}