@redocly/openapi-docs 3.12.0 → 3.12.2

package/lib/models/schema.js

@@ -1,2 +1,474 @@
-import{REDOCLY_TEAMS_RBAC as h}from"@redocly/config";import{isObject as I}from"@redocly/theme/core/openapi";import{pushRef as M}from"../services/OpenAPIParser.js";import{detectType as w,extractExtensions as q,getValueFromMdParsedExtension as S,humanizeConstraints as C,isNamedDefinition as j,isPrimitiveType as E,JsonPointer as b,pluralizeType as B,sortByDeprecated as z,sortByRequired as L}from"../utils/index.js";import{getField as T}from"./field.js";function F({parser:i,schemaOrRef:n,pointer:u,options:a,isChild:y=!1,baseRefsStack:f=[],deps:o,absolutePointer:p}){const{resolved:c,refsStack:m}=i.deref(n,f,!0),r=n.$ref||u||p||"",l=M(m,r),e=i.mergeAllOf(c,r,l,n.$ref||p),d=e.type||w(e),t={operationPointer:o.operation?.pointer||p||"",schemaOrRef:n,isChild:y,typePrefix:"",pointer:r,absolutePointer:p,refsStack:l,rawSchema:c,type:d,isCircular:!!e["x-circular-ref"],isComplex:!!e["x-complex"],title:e.title||j(r)&&b.baseName(r)||"",description:S(e,"description")||"",format:e.format,enum:e.enum||[],example:e.example,deprecated:!!e.deprecated,pattern:e.pattern,externalDocs:e.externalDocs,displayFormat:e.format,isPrimitive:E(e,d),constraints:C(e),default:e.default,readOnly:!!e.readOnly,writeOnly:!!e.writeOnly,const:e.const||"",contentEncoding:e.contentEncoding,contentMediaType:e.contentMediaType,minItems:e.minItems,maxItems:e.maxItems,nullable:e.nullable||e["x-nullable"],schema:e,displayType:"",items:void 0,extensions:void 0,oneOfType:"",discriminatorProp:void 0,oneOf:void 0,[h]:e[h],"x-enumDescriptions":S(e,"x-enumDescriptions"),get fields(){if(!t.isCircular&&!t.isComplex&&($(t,"object")||$(t,"array")&&D(e)))return _(i,e,r,a,l,o)}};if((e.nullable||e["x-nullable"])&&(Array.isArray(t.type)&&!t.type.some(s=>s===null||s==="null")?t.type=[...t.type,"null"]:!Array.isArray(t.type)&&(t.type!==null||t.type!=="null")&&(t.type=[t.type,"null"])),t.displayType=Array.isArray(t.type)?t.type.map(s=>s===null?"null":s).join(" or "):t.type,t.isCircular)return t;if(e.if&&e.then||e.if&&e.else){const{oneOf:s,oneOfType:P}=V({schema:e,parser:i,pointer:r,options:a,deps:o,refsStack:l});return t.oneOf=s,t.oneOfType=P,t}if(!y&&v(e)!==void 0){const{oneOf:s,discriminatorProp:P}=J({schema:e,parser:i,deps:o,mergedSchema:e,options:a,pointer:r,refsStack:l});return t.oneOf=s,t.discriminatorProp=P,t}else y&&Array.isArray(e.oneOf)&&e.oneOf.find(s=>s.$ref===r)&&delete e.oneOf;if(e.oneOf!==void 0){const{oneOf:s,displayType:P}=k({schemaOneOf:e.oneOf,parser:i,deps:o,options:a,pointer:r,refsStack:l,schema:e});return t.oneOfType="One of",s&&(t.oneOf=s),t.displayType=P,e.anyOf!==void 0&&console.warn(`oneOf and anyOf are not supported on the same level. Skipping anyOf at ${r}`),t}if(e.anyOf!==void 0){const{oneOf:s,displayType:P}=k({schemaOneOf:e.anyOf,parser:i,deps:o,options:a,pointer:r,refsStack:l,schema:e});return s&&(t.oneOf=s),t.displayType=P,t.oneOfType="Any of",t}if($(t,"array")&&(e.items&&!D(e)&&(t.items=F({parser:i,schemaOrRef:Object.assign({type:"object"},e.items),pointer:r+"/items",options:a,baseRefsStack:l,deps:o,absolutePointer:b.join(e.absolutePointer||"",["items"])})),t.displayType=e.prefixItems||Array.isArray(e.items)?"items":B(t.items?.displayType||t.displayType),t.displayFormat=t.items?.format||"",t.typePrefix=t.items?.typePrefix||"Array of ",t.title=t.title||t.items?.title||"",t.isPrimitive=t.items?.isPrimitive!==void 0?t.items?.isPrimitive:t.isPrimitive,t.example===void 0&&t.items?.example!==void 0&&(t.example=[t.items.example]),t.items?.isPrimitive&&(t.enum=t.items.enum,t["x-enumDescriptions"]=S(t.items,"x-enumDescriptions")),Array.isArray(t.type))){const s=t.type.filter(P=>P!=="array");s.length&&(t.displayType+=` or ${s.join(" or ")}`)}return a.showExtensions&&(t.extensions=q(e,a.showExtensions)),t}function J({schema:i,parser:n,pointer:u,options:a,refsStack:y,deps:f,mergedSchema:o}){const p=v(i),c=p?.propertyName,m=n.findDerived([...o["x-parentRefs"]||[],u]);if(i.oneOf)for(const O of i.oneOf){if(O.$ref===void 0)continue;const x=b.baseName(O.$ref);m[O.$ref]=x}const r=p?.mapping||{};let l=p?.["x-explicitMappingOnly"]||!1;Object.keys(r).length===0&&(l=!1);const e={};for(const O in r){const x=r[O];Array.isArray(e[x])?e[x].push(O):e[x]=[O]}const d=l?{...e}:{...m,...e};let t=[];for(const O of Object.keys(d)){const x=d[O];if(Array.isArray(x))for(const A of x)t.push({$ref:O,name:A});else t.push({$ref:O,name:x})}const s=Object.keys(r);return s.length!==0&&(t=t.sort((O,x)=>{const A=s.indexOf(O.name),g=s.indexOf(x.name);return A<0&&g<0?O.name.localeCompare(x.name):A<0?1:g<0?-1:A-g})),{oneOf:t.map(({$ref:O,name:x},A)=>{const g=F({parser:n,schemaOrRef:{$ref:O},pointer:O,options:a,isChild:!0,baseRefsStack:y.slice(0,-1),deps:{...f,parentFieldFullPath:f.parentFieldFullPath?f.parentFieldFullPath+"&d="+A:"&d="+A.toString()},absolutePointer:o.absolutePointer});return g.title=x,g}),discriminatorProp:c}}function k({schemaOneOf:i,parser:n,refsStack:u,pointer:a,schema:y,options:f,deps:o}){const p=i.map((m,r)=>{const{resolved:l,refsStack:e}=n.deref(m,u,!0),d=n.mergeAllOf(l,a+"/oneOf/"+r,e),t=j(m.$ref)&&!d.title?b.baseName(m.$ref):`${d.title||""}${d.const&&JSON.stringify(d.const)||""}`;return F({parser:n,schemaOrRef:{...d,title:t,allOf:[{...y,oneOf:void 0,anyOf:void 0}],discriminator:l.allOf?void 0:d.discriminator},pointer:m.$ref||a+"/oneOf/"+r,options:f,baseRefsStack:e,deps:{...o,parentFieldFullPath:o.parentFieldFullPath?o.parentFieldFullPath+"&oneOf="+r:"&oneOf="+r.toString()}})}),c=[...new Set(p.map(m=>{let r=m.typePrefix+(m.title&&!f.hideSchemaTitles?`${m.title} (${m.displayType})`:m.displayType);return r.indexOf(" or ")>-1&&(r=`(${r})`),r}))].join(" or ");return{oneOf:p,displayType:c}}function V({schema:i,parser:n,pointer:u,options:a,refsStack:y,deps:f}){const{if:o,else:p={},then:c={},...m}=i;return{oneOf:[{allOf:[m,c,o],title:o&&o["x-displayName"]||o?.title||"case 1"},{allOf:[m,p],title:p&&p["x-displayName"]||p?.title||"case 2"}].map((d,t)=>F({parser:n,schemaOrRef:{...d},pointer:u+"/oneOf/"+t,options:a,baseRefsStack:y,deps:{...f,parentFieldFullPath:f.parentFieldFullPath?f.parentFieldFullPath+"&oneOf="+t:"&oneOf="+t.toString()}})),oneOfType:"One of"}}function R(i,n,u){return i||(console.warn(`Field "${n}" is invalid, skipping.
- Field must be an object but got ${typeof i} at "${u}"`),{})}function _(i,n,u,a,y,f){let o=n.properties||($(n,"array")?n.prefixItems||n.items:void 0)||{};const p=n.patternProperties||{},c=n.additionalProperties||n.unevaluatedProperties,m=n.prefixItems?n.items:n.additionalItems,r=n.default||{};let l=Object.keys(o).map(e=>{const d=R(o[e],e,u),t=n.required===void 0?!1:n.required.indexOf(e)>-1;return T(i,{name:n.properties?e:`[${e}]`,required:t,schema:{...d,example:n.example?.[e]||d.example,default:d.default===void 0&&r?r[e]:d.default}},u+"/properties/"+e,a,f,y,b.join(n.absolutePointer||"",["properties",e]))});return a.sortRequiredPropsFirst&&(l=L(l,n.required)),l.push(...Object.keys(p).map(e=>{const d=R(p[e],e,u);return T(i,{name:e,required:!1,schema:d,kind:"patternProperties"},`${u}/patternProperties/${e}`,a,f,y)})),(I(c)||c===!0)&&l.push(T(i,{name:(I(c)&&c["x-additionalPropertiesName"]||"property name").concat("*"),required:!1,schema:c===!0?{}:c,kind:"additionalProperties"},u+"/additionalProperties",a,f,y,b.join(n.absolutePointer||"",["additionalProperties"]))),l.push(...Y({parser:i,schema:m,fieldsCount:l.length,$ref:u,options:a,refsStack:y,deps:f})),z(l)}function Y({parser:i,schema:n=!1,fieldsCount:u,$ref:a,options:y,refsStack:f,deps:o}){return typeof n=="boolean"?n?[T(i,{name:`[${u}...]`,schema:{},kind:"additionalItems"},`${a}/additionalItems`,y,o,f)]:[]:Array.isArray(n)?[...n.map((p,c)=>T(i,{name:`[${u+c}]`,schema:p,kind:"additionalItems"},`${a}/additionalItems/${c}`,y,o,f))]:I(n)?[T(i,{name:`[${u}...]`,schema:n,kind:"additionalItems"},`${a}/additionalItems`,y,o,f)]:[]}function v(i){return i.discriminator||i["x-discriminator"]}function $(i,n){return i.type===n||Array.isArray(i.type)&&i.type.includes(n)}function D(i){return!!(Array.isArray(i.items)||Array.isArray(i.prefixItems))}export{F as getSchema};
+import { REDOCLY_TEAMS_RBAC } from '@redocly/config';
+import { isObject } from '@redocly/theme/core/openapi';
+import { pushRef } from '../services/OpenAPIParser.js';
+import { detectType, extractExtensions, getValueFromMdParsedExtension, humanizeConstraints, isNamedDefinition, isPrimitiveType, JsonPointer, pluralizeType, sortByDeprecated, sortByRequired, } from '../utils/index.js';
+import { getField } from './field.js';
+export function getSchema({ parser, schemaOrRef, pointer, options, isChild = false, baseRefsStack = [], deps, absolutePointer, }) {
+    const { resolved, refsStack: newRefsStack } = parser.deref(schemaOrRef, baseRefsStack, true);
+    const schemaPointer = schemaOrRef.$ref || pointer || absolutePointer || '';
+    const refsStack = pushRef(newRefsStack, schemaPointer);
+    const schema = parser.mergeAllOf(resolved, schemaPointer, refsStack, schemaOrRef.$ref || absolutePointer);
+    const type = schema.type || detectType(schema);
+    const schemaModel = {
+        operationPointer: deps.operation?.pointer || absolutePointer || '',
+        schemaOrRef,
+        isChild,
+        typePrefix: '',
+        pointer: schemaPointer,
+        absolutePointer,
+        refsStack,
+        rawSchema: resolved,
+        type,
+        isCircular: !!schema['x-circular-ref'],
+        isComplex: !!schema['x-complex'],
+        title: schema.title ||
+            (isNamedDefinition(schemaPointer) && JsonPointer.baseName(schemaPointer)) ||
+            '',
+        description: getValueFromMdParsedExtension(schema, 'description') || '',
+        format: schema.format,
+        enum: schema.enum || [],
+        example: schema.example,
+        deprecated: !!schema.deprecated,
+        pattern: schema.pattern,
+        externalDocs: schema.externalDocs,
+        displayFormat: schema.format,
+        isPrimitive: isPrimitiveType(schema, type),
+        constraints: humanizeConstraints(schema),
+        default: schema.default,
+        readOnly: !!schema.readOnly,
+        writeOnly: !!schema.writeOnly,
+        const: schema.const || '',
+        contentEncoding: schema.contentEncoding,
+        contentMediaType: schema.contentMediaType,
+        minItems: schema.minItems,
+        maxItems: schema.maxItems,
+        nullable: schema.nullable || schema['x-nullable'],
+        schema,
+        displayType: '',
+        items: undefined,
+        extensions: undefined,
+        oneOfType: '',
+        discriminatorProp: undefined,
+        oneOf: undefined,
+        [REDOCLY_TEAMS_RBAC]: schema[REDOCLY_TEAMS_RBAC],
+        ['x-enumDescriptions']: getValueFromMdParsedExtension(schema, 'x-enumDescriptions'),
+        get fields() {
+            if (!schemaModel.isCircular &&
+                !schemaModel.isComplex &&
+                (hasType(schemaModel, 'object') || (hasType(schemaModel, 'array') && hasArrayItems(schema)))) {
+                return buildFields(parser, schema, schemaPointer, options, refsStack, deps);
+            }
+            return;
+        },
+    };
+    if (schema.nullable || schema['x-nullable']) {
+        if (Array.isArray(schemaModel.type) &&
+            !schemaModel.type.some((value) => value === null || value === 'null')) {
+            schemaModel.type = [...schemaModel.type, 'null'];
+        }
+        else if (!Array.isArray(schemaModel.type) &&
+            (schemaModel.type !== null || schemaModel.type !== 'null')) {
+            schemaModel.type = [schemaModel.type, 'null'];
+        }
+    }
+    schemaModel.displayType = Array.isArray(schemaModel.type)
+        ? schemaModel.type.map((item) => (item === null ? 'null' : item)).join(' or ')
+        : schemaModel.type;
+    if (schemaModel.isCircular) {
+        return schemaModel;
+    }
+    if ((schema.if && schema.then) || (schema.if && schema.else)) {
+        const { oneOf, oneOfType } = initConditionalOperators({
+            schema,
+            parser,
+            pointer: schemaPointer,
+            options,
+            deps,
+            refsStack,
+        });
+        schemaModel.oneOf = oneOf;
+        schemaModel.oneOfType = oneOfType;
+        return schemaModel;
+    }
+    if (!isChild && getDiscriminator(schema) !== undefined) {
+        const { oneOf, discriminatorProp } = initDiscriminator({
+            schema,
+            parser,
+            deps: deps,
+            mergedSchema: schema,
+            options: options,
+            pointer: schemaPointer,
+            refsStack,
+        });
+        schemaModel.oneOf = oneOf;
+        schemaModel.discriminatorProp = discriminatorProp;
+        return schemaModel;
+    }
+    else if (isChild &&
+        Array.isArray(schema.oneOf) &&
+        schema.oneOf.find((s) => s.$ref === schemaPointer)) {
+        // we hit allOf of the schema with the parent discriminator
+        delete schema.oneOf;
+    }
+    if (schema.oneOf !== undefined) {
+        const { oneOf, displayType } = initOneOf({
+            schemaOneOf: schema.oneOf,
+            parser,
+            deps,
+            options,
+            pointer: schemaPointer,
+            refsStack,
+            schema,
+        });
+        schemaModel.oneOfType = 'One of';
+        if (oneOf) {
+            schemaModel.oneOf = oneOf;
+        }
+        schemaModel.displayType = displayType;
+        if (schema.anyOf !== undefined) {
+            console.warn(`oneOf and anyOf are not supported on the same level. Skipping anyOf at ${schemaPointer}`);
+        }
+        return schemaModel;
+    }
+    if (schema.anyOf !== undefined) {
+        const { oneOf, displayType } = initOneOf({
+            schemaOneOf: schema.anyOf,
+            parser,
+            deps,
+            options,
+            pointer: schemaPointer,
+            refsStack,
+            schema,
+        });
+        if (oneOf) {
+            schemaModel.oneOf = oneOf;
+        }
+        schemaModel.displayType = displayType;
+        schemaModel.oneOfType = 'Any of';
+        return schemaModel;
+    }
+    if (hasType(schemaModel, 'array')) {
+        if (schema.items && !hasArrayItems(schema)) {
+            schemaModel.items = getSchema({
+                parser,
+                schemaOrRef: Object.assign({ type: 'object' }, schema.items),
+                pointer: schemaPointer + '/items',
+                options,
+                baseRefsStack: refsStack,
+                deps,
+                absolutePointer: JsonPointer.join(schema.absolutePointer || '', ['items']),
+            });
+        }
+        schemaModel.displayType =
+            schema.prefixItems || Array.isArray(schema.items)
+                ? 'items'
+                : pluralizeType(schemaModel.items?.displayType || schemaModel.displayType);
+        schemaModel.displayFormat = schemaModel.items?.format || '';
+        schemaModel.typePrefix = schemaModel.items?.typePrefix || '' + 'Array of ';
+        schemaModel.title = schemaModel.title || schemaModel.items?.title || '';
+        schemaModel.isPrimitive =
+            schemaModel.items?.isPrimitive !== undefined
+                ? schemaModel.items?.isPrimitive
+                : schemaModel.isPrimitive;
+        if (schemaModel.example === undefined && schemaModel.items?.example !== undefined) {
+            schemaModel.example = [schemaModel.items.example];
+        }
+        if (schemaModel.items?.isPrimitive) {
+            schemaModel.enum = schemaModel.items.enum;
+            schemaModel['x-enumDescriptions'] = getValueFromMdParsedExtension(schemaModel.items, 'x-enumDescriptions');
+        }
+        if (Array.isArray(schemaModel.type)) {
+            const filteredType = schemaModel.type.filter((item) => item !== 'array');
+            if (filteredType.length) {
+                schemaModel.displayType += ` or ${filteredType.join(' or ')}`;
+            }
+        }
+    }
+    if (options.showExtensions) {
+        schemaModel.extensions = extractExtensions(schema, options.showExtensions);
+    }
+    return schemaModel;
+}
+function initDiscriminator({ schema, parser, pointer, options, refsStack, deps, mergedSchema, }) {
+    const discriminator = getDiscriminator(schema);
+    const discriminatorProp = discriminator?.propertyName;
+    const implicitInvertedMapping = parser.findDerived([
+        ...(mergedSchema['x-parentRefs'] || []),
+        pointer,
+    ]);
+    if (schema.oneOf) {
+        for (const variant of schema.oneOf) {
+            if (variant.$ref === undefined) {
+                continue;
+            }
+            const name = JsonPointer.baseName(variant.$ref);
+            implicitInvertedMapping[variant.$ref] = name;
+        }
+    }
+    const mapping = discriminator?.mapping || {};
+    // Defines if the mapping is exhaustive. This avoids having references
+    // that overlap with the mapping entries
+    let isLimitedToMapping = discriminator?.['x-explicitMappingOnly'] || false;
+    // if there are no mappings, assume non-exhaustive
+    if (Object.keys(mapping).length === 0) {
+        isLimitedToMapping = false;
+    }
+    const explicitInvertedMapping = {};
+    for (const name in mapping) {
+        const $ref = mapping[name];
+        if (Array.isArray(explicitInvertedMapping[$ref])) {
+            explicitInvertedMapping[$ref].push(name);
+        }
+        else {
+            // overrides implicit mapping here
+            explicitInvertedMapping[$ref] = [name];
+        }
+    }
+    const invertedMapping = isLimitedToMapping
+        ? { ...explicitInvertedMapping }
+        : { ...implicitInvertedMapping, ...explicitInvertedMapping };
+    let refs = [];
+    for (const $ref of Object.keys(invertedMapping)) {
+        const names = invertedMapping[$ref];
+        if (Array.isArray(names)) {
+            for (const name of names) {
+                refs.push({ $ref, name });
+            }
+        }
+        else {
+            refs.push({ $ref, name: names });
+        }
+    }
+    // Make the listing respects the mapping
+    // in case a mapping is defined, the user usually wants to have the order shown
+    // as it was defined in the yaml. This will sort the names given the provided
+    // mapping (if provided).
+    // The logic is:
+    // - If a name is among the mapping, promote it to first
+    // - Names among the mapping are sorted by their order in the mapping
+    // - Names outside the mapping are sorted alphabetically
+    const names = Object.keys(mapping);
+    if (names.length !== 0) {
+        refs = refs.sort((left, right) => {
+            const indexLeft = names.indexOf(left.name);
+            const indexRight = names.indexOf(right.name);
+            if (indexLeft < 0 && indexRight < 0) {
+                // out of mapping, order by name
+                return left.name.localeCompare(right.name);
+            }
+            else if (indexLeft < 0) {
+                // the right is found, so mapping wins
+                return 1;
+            }
+            else if (indexRight < 0) {
+                // left wins as it's in mapping
+                return -1;
+            }
+            else {
+                return indexLeft - indexRight;
+            }
+        });
+    }
+    const oneOf = refs.map(({ $ref, name }, index) => {
+        const innerSchema = getSchema({
+            parser,
+            schemaOrRef: { $ref },
+            pointer: $ref,
+            options,
+            isChild: true,
+            baseRefsStack: refsStack.slice(0, -1),
+            deps: {
+                ...deps,
+                parentFieldFullPath: deps.parentFieldFullPath
+                    ? deps.parentFieldFullPath + '&d=' + index
+                    : '&d=' + index.toString(),
+            },
+            absolutePointer: mergedSchema.absolutePointer,
+        });
+        innerSchema.title = name;
+        return innerSchema;
+    });
+    return {
+        oneOf,
+        discriminatorProp,
+    };
+}
+function initOneOf({ schemaOneOf, parser, refsStack, pointer, schema, options, deps, }) {
+    const oneOf = schemaOneOf.map((variant, idx) => {
+        const { resolved: derefVariant, refsStack: derefRefsStack } = parser.deref(variant, refsStack, true);
+        const merged = parser.mergeAllOf(derefVariant, pointer + '/oneOf/' + idx, derefRefsStack);
+        // try to infer title
+        const title = isNamedDefinition(variant.$ref) && !merged.title
+            ? JsonPointer.baseName(variant.$ref)
+            : `${merged.title || ''}${(merged.const && JSON.stringify(merged.const)) || ''}`;
+        const resultSchema = getSchema({
+            parser,
+            // merge base schema into each of oneOf's subschemas
+            schemaOrRef: {
+                // variant may already have allOf so merge it to not get overwritten
+                ...merged,
+                title,
+                allOf: [{ ...schema, oneOf: undefined, anyOf: undefined }],
+                // if specific child schemas are listed in oneOf/anyOf, they are not supposed to be discriminated
+                discriminator: derefVariant.allOf ? undefined : merged.discriminator,
+            },
+            pointer: variant.$ref || pointer + '/oneOf/' + idx,
+            options,
+            baseRefsStack: derefRefsStack,
+            deps: {
+                ...deps,
+                parentFieldFullPath: deps.parentFieldFullPath
+                    ? deps.parentFieldFullPath + '&oneOf=' + idx
+                    : '&oneOf=' + idx.toString(),
+            },
+        });
+        return resultSchema;
+    });
+    const displayType = [
+        ...new Set(oneOf.map((schema) => {
+            let name = schema.typePrefix +
+                (schema.title && !options.hideSchemaTitles
+                    ? `${schema.title} (${schema.displayType})`
+                    : schema.displayType);
+            if (name.indexOf(' or ') > -1) {
+                name = `(${name})`;
+            }
+            return name;
+        })),
+    ].join(' or ');
+    return { oneOf, displayType };
+}
+function initConditionalOperators({ schema, parser, pointer, options, refsStack, deps, }) {
+    const { if: ifOperator, else: elseOperator = {}, then: thenOperator = {}, ...restSchema } = schema;
+    const groupedOperators = [
+        {
+            allOf: [restSchema, thenOperator, ifOperator],
+            title: (ifOperator && ifOperator['x-displayName']) || ifOperator?.title || 'case 1',
+        },
+        {
+            allOf: [restSchema, elseOperator],
+            title: (elseOperator && elseOperator['x-displayName']) || elseOperator?.title || 'case 2',
+        },
+    ];
+    const oneOf = groupedOperators.map((variant, idx) => getSchema({
+        parser,
+        schemaOrRef: {
+            ...variant,
+        },
+        pointer: pointer + '/oneOf/' + idx,
+        options,
+        baseRefsStack: refsStack,
+        deps: {
+            ...deps,
+            parentFieldFullPath: deps.parentFieldFullPath
+                ? deps.parentFieldFullPath + '&oneOf=' + idx
+                : '&oneOf=' + idx.toString(),
+        },
+    }));
+    const oneOfType = 'One of';
+    return { oneOf, oneOfType };
+}
+function normalizeField(field, fieldName, $ref) {
+    if (field) {
+        return field;
+    }
+    console.warn(`Field "${fieldName}" is invalid, skipping.\n Field must be an object but got ${typeof field} at "${$ref}"`);
+    return {};
+}
+function buildFields(parser, schema, $ref, options, refsStack, deps) {
+    let props = schema.properties ||
+        (hasType(schema, 'array') ? schema.prefixItems || schema.items : undefined) ||
+        {};
+    const patternProps = schema.patternProperties || {};
+    // TODO: if schema has $ref and allOf,anyOf,oneOf,if,then,else, ignore schema.additionalProperties
+    const additionalProps = schema.additionalProperties || schema.unevaluatedProperties;
+    const itemsProps = schema.prefixItems ? schema.items : schema.additionalItems;
+    const defaults = schema.default || {};
+    let fields = Object.keys(props).map((fieldName) => {
+        const field = normalizeField(props[fieldName], fieldName, $ref);
+        const required = schema.required === undefined ? false : schema.required.indexOf(fieldName) > -1;
+        return getField(parser, {
+            name: schema.properties ? fieldName : `[${fieldName}]`,
+            required,
+            schema: {
+                ...field,
+                example: schema.example?.[fieldName] || field.example,
+                default: field.default === undefined && defaults ? defaults[fieldName] : field.default,
+            },
+        }, $ref + '/properties/' + fieldName, options, deps, refsStack, JsonPointer.join(schema.absolutePointer || '', ['properties', fieldName]));
+    });
+    if (options.sortRequiredPropsFirst) {
+        fields = sortByRequired(fields, schema.required);
+    }
+    fields.push(...Object.keys(patternProps).map((fieldName) => {
+        const field = normalizeField(patternProps[fieldName], fieldName, $ref);
+        return getField(parser, {
+            name: fieldName,
+            required: false,
+            schema: field,
+            kind: 'patternProperties',
+        }, `${$ref}/patternProperties/${fieldName}`, options, deps, refsStack);
+    }));
+    if (isObject(additionalProps) || additionalProps === true) {
+        fields.push(getField(parser, {
+            name: (isObject(additionalProps)
+                ? additionalProps['x-additionalPropertiesName'] || 'property name'
+                : 'property name').concat('*'),
+            required: false,
+            schema: additionalProps === true ? {} : additionalProps,
+            kind: 'additionalProperties',
+        }, $ref + '/additionalProperties', options, deps, refsStack, JsonPointer.join(schema.absolutePointer || '', ['additionalProperties'])));
+    }
+    fields.push(...buildAdditionalItems({
+        parser,
+        schema: itemsProps,
+        fieldsCount: fields.length,
+        $ref,
+        options,
+        refsStack,
+        deps,
+    }));
+    return sortByDeprecated(fields);
+}
+function buildAdditionalItems({ parser, schema = false, fieldsCount, $ref, options, refsStack, deps, }) {
+    if (typeof schema === 'boolean') {
+        return schema
+            ? [
+                getField(parser, {
+                    name: `[${fieldsCount}...]`,
+                    schema: {},
+                    kind: 'additionalItems',
+                }, `${$ref}/additionalItems`, options, deps, refsStack),
+            ]
+            : [];
+    }
+    if (Array.isArray(schema)) {
+        return [
+            ...schema.map((field, idx) => getField(parser, {
+                name: `[${fieldsCount + idx}]`,
+                schema: field,
+                kind: 'additionalItems',
+            }, `${$ref}/additionalItems/${idx}`, options, deps, refsStack)),
+        ];
+    }
+    if (isObject(schema)) {
+        return [
+            getField(parser, {
+                name: `[${fieldsCount}...]`,
+                schema: schema,
+                kind: 'additionalItems',
+            }, `${$ref}/additionalItems`, options, deps, refsStack),
+        ];
+    }
+    return [];
+}
+function getDiscriminator(schema) {
+    return schema.discriminator || schema['x-discriminator'];
+}
+function hasType(schema, type) {
+    return schema.type === type || (Array.isArray(schema.type) && schema.type.includes(type));
+}
+function hasArrayItems(schema) {
+    return Boolean(Array.isArray(schema.items) || Array.isArray(schema.prefixItems));
+}
+//# sourceMappingURL=schema.js.map

package/lib/models/security.js

@@ -1 +1,84 @@
-import{getValueFromMdParsedExtension as d}from"../utils/index.js";function l(e=[],t){return e.map(n=>p({requirement:n,parser:t})).filter(({schemes:n})=>n.length>0)}function p({requirement:e,parser:t}){const n=t.definition.components&&t.definition.components.securitySchemes||{};return{schemes:Object.keys(e||{}).map(o=>{const s=t.deref(n[o]).resolved,r=e[o]||[];if(s)return{...s,id:o,sectionId:o,scopes:r}}).filter(Boolean)}}function a(e,t,n){if(!e?.deref)return{};const{resolved:c}=e.deref(n),o=t,s=c.type,r=d(c,"description")||"";let i,f,m,u={};switch(c.type){case"apiKey":{i={name:c.name,in:c.in};break}case"http":{f={scheme:c.scheme,bearerFormat:c.bearerFormat};break}case"openIdConnect":{m={connectUrl:c.openIdConnectUrl};break}case"oauth2":{u=c.flows;break}}return{id:t,sectionId:o,type:s,description:r,apiKey:i,http:f,flows:u,openId:m}}function y({parser:e}){if(!e)return[];const t=e.definition?.components?.securitySchemes||{};return Object.keys(t).map(n=>a(e,n,t[n]))}export{l as getSecurity,a as getSecurityScheme,y as getSecuritySchemes};
+import { getValueFromMdParsedExtension } from '../utils/index.js';
+export function getSecurity(requirements = [], parser) {
+    return requirements
+        .map((requirement) => getSecurityRequirement({ requirement, parser }))
+        .filter(({ schemes }) => schemes.length > 0);
+}
+function getSecurityRequirement({ requirement, parser, }) {
+    const schemes = (parser.definition.components && parser.definition.components.securitySchemes) || {};
+    const filteredSchemes = Object.keys(requirement || {})
+        .map((id) => {
+        const scheme = parser.deref(schemes[id]).resolved;
+        const scopes = requirement[id] || [];
+        if (!scheme) {
+            return undefined;
+        }
+        return {
+            ...scheme,
+            id,
+            sectionId: id,
+            scopes,
+        };
+    })
+        .filter(Boolean);
+    return {
+        schemes: filteredSchemes,
+    };
+}
+export function getSecurityScheme(parser, id, scheme) {
+    if (!parser?.deref) {
+        return {};
+    }
+    const { resolved: info } = parser.deref(scheme);
+    const sectionId = id;
+    const type = info.type;
+    const description = getValueFromMdParsedExtension(info, 'description') || '';
+    let apiKey = undefined;
+    let http = undefined;
+    let openId = undefined;
+    let flows = {};
+    switch (info.type) {
+        case 'apiKey': {
+            apiKey = {
+                name: info.name,
+                in: info.in,
+            };
+            break;
+        }
+        case 'http': {
+            http = {
+                scheme: info.scheme,
+                bearerFormat: info.bearerFormat,
+            };
+            break;
+        }
+        case 'openIdConnect': {
+            openId = {
+                connectUrl: info.openIdConnectUrl,
+            };
+            break;
+        }
+        case 'oauth2': {
+            flows = info.flows;
+            break;
+        }
+    }
+    return {
+        id,
+        sectionId,
+        type,
+        description,
+        apiKey,
+        http,
+        flows,
+        openId,
+    };
+}
+export function getSecuritySchemes({ parser, }) {
+    if (!parser) {
+        return [];
+    }
+    const schemes = parser.definition?.components?.securitySchemes || {};
+    return Object.keys(schemes).map((name) => getSecurityScheme(parser, name, schemes[name]));
+}
+//# sourceMappingURL=security.js.map

package/lib/models/tab.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tab.js.map

package/lib/models/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map