@redocly/openapi-docs 3.12.0-rc.7 → 3.12.1

package/lib/services/history/helpers.js

@@ -1 +1,63 @@
-import{encodeBackSlashes as o,queryString as s}from"../../utils/index.js";import{getActiveMediaType as r}from"../../models/mediaContent.js";function d(e,n){return e===n||"#"+e===n||e==="#"+n}function p(e,n){if(!e.in){if(e.deps.type==="request"&&e.deps.operation?.requestBody?.content?.mediaTypes)return e.deps.operation?.requestBody?.content?.mediaTypes.length>1?e.deps.operation?.requestBody?.content&&r(e.deps.operation.requestBody.content,n).name:void 0;if(e.deps.type==="response"&&e.deps.response?.content?.mediaTypes)return e.deps.response?.content?.mediaTypes.length>1?e.deps.response?.content&&r(e.deps.response.content,n).name:void 0}}function a(e,n){if(!e)return"";const t={t:e.deps.type,in:e.in||e.deps.in,c:e.deps.type==="response"?e.deps.response?.code:void 0,cb:e.deps.operation?.isCallback?e.deps.operation.callbackId:void 0,ct:p(e,n),path:e.fieldFullPath};return s.stringify(t,{encode:!1,sort:!1})}function c(e="",n="",t="/"){return e.endsWith(t)&&(e=e.slice(0,-t.length)),n.startsWith(t)&&(n=n.slice(t.length)),!e||!n?e+n:e+t+n}function y(e,n){return e=o(e),(`/${e}#`+c(e,n)).toLowerCase()}export{a as constructFieldDeepFragment,d as isSameHash,c as joinWithSeparator,y as makeDeepLink};
+import { encodeBackSlashes, queryString } from '../../utils/index.js';
+import { getActiveMediaType } from '../../models/mediaContent.js';
+export function isSameHash(a, b) {
+    return a === b || '#' + a === b || a === '#' + b;
+}
+// TODO: Add tests
+function getContentTypeName(field, activeMimeName) {
+    // param in "query" | "header" | "path" | "cookie" - no need for content type in link
+    if (field.in) {
+        return;
+    }
+    // Use content type from requestBody
+    if (field.deps.type === 'request') {
+        if (field.deps.operation?.requestBody?.content?.mediaTypes) {
+            return field.deps.operation?.requestBody?.content?.mediaTypes.length > 1
+                ? field.deps.operation?.requestBody?.content &&
+                    getActiveMediaType(field.deps.operation.requestBody.content, activeMimeName).name
+                : undefined; // if only one content type present - also no need for content type in link
+        }
+    }
+    // Use content type from response
+    if (field.deps.type === 'response') {
+        if (field.deps.response?.content?.mediaTypes) {
+            return field.deps.response?.content?.mediaTypes.length > 1
+                ? field.deps.response?.content &&
+                    getActiveMediaType(field.deps.response.content, activeMimeName).name
+                : undefined; // if only one content type present - also no need for content type in link
+        }
+    }
+    return;
+}
+// TODO: Add tests
+export function constructFieldDeepFragment(field, activeMimeName) {
+    if (!field) {
+        return '';
+    }
+    const linkParams = {
+        t: field.deps.type, // "request" | "response"
+        in: field.in || field.deps.in, // "query" | "header" | "path" | "cookie" // TODO: remove 'in' from deps
+        c: field.deps.type === 'response' ? field.deps.response?.code : undefined, // response code: 200 | 201 | 400 | etc
+        cb: field.deps.operation?.isCallback ? field.deps.operation.callbackId : undefined, // Callback
+        ct: getContentTypeName(field, activeMimeName),
+        path: field.fieldFullPath, // Field deep path
+    };
+    return queryString.stringify(linkParams, { encode: false, sort: false });
+}
+export function joinWithSeparator(base = '', path = '', sep = '/') {
+    if (base.endsWith(sep)) {
+        base = base.slice(0, -sep.length);
+    }
+    if (path.startsWith(sep)) {
+        path = path.slice(sep.length);
+    }
+    if (!base || !path) {
+        return base + path;
+    }
+    return base + sep + path;
+}
+export function makeDeepLink(operationId, suffix) {
+    operationId = encodeBackSlashes(operationId);
+    return (`/${operationId}#` + joinWithSeparator(operationId, suffix)).toLowerCase();
+}
+//# sourceMappingURL=helpers.js.map

package/lib/services/history/index.js

@@ -1 +1,2 @@
-export*from"./helpers.js";
+export * from './helpers.js'; // TODO: move or remove
+//# sourceMappingURL=index.js.map

package/lib/services/index.js

@@ -1 +1,9 @@
-export*from"./history/index.js";export*from"./code-samples/index.js";export*from"./types.js";import{OpenAPIParser as m}from"./OpenAPIParser.js";import{buildContentItems as x}from"./menu/index.js";export*from"./types.js";export*from"./config-options/index.js";import{deepClone as s}from"./utils.js";export{m as OpenAPIParser,x as buildContentItems,s as deepClone};
+export * from './history/index.js';
+export * from './code-samples/index.js';
+export * from './types.js';
+export { OpenAPIParser } from './OpenAPIParser.js';
+export { buildContentItems } from './menu/index.js';
+export * from './types.js';
+export * from './config-options/index.js';
+export { deepClone } from './utils.js';
+//# sourceMappingURL=index.js.map

package/lib/services/menu/builder.js

@@ -1 +1,47 @@
-import{getTagGroupsItems as r,getTagsItems as d,getTagsWithOperations as c}from"./tags.js";import{addMarkdownItems as g}from"./markdown.js";import{flattenByProp as p,getValueFromMdParsedExtension as h}from"../../utils/index.js";import{DEFAULT_WEBHOOKS_TAG_NAME as u}from"../../constants.js";function l(t,n){const{definition:e}=t,{schemaDefinitionsTagName:i}=n,s=[{id:"",name:e?.info?.["x-seo"]?.title||e?.info?.title||"Overview",href:"/",depth:1,level:1,type:"section",infoDefinition:e.info,items:[]}],o=[...e.tags||[]];o.some(a=>a.name===u)||o.push({name:u}),!o.find(a=>a?.name===i)&&i&&o.push({name:i});const f=c(t,o),m=e["x-tagGroups"];return s.push(...g(h(e.info,"description")||"",void 0,1)),m&&m.length>0?s.push(...r(t,void 0,m,f,n)):s.push(...d(t,f,void 0,void 0,n)),s}function E(t,n){const e=l(t,n),i=p(e||[],"items");return{contentItems:e,flatItems:i}}export{E as buildContentItems,l as buildMenuStructure};
+import { getTagGroupsItems, getTagsItems, getTagsWithOperations } from './tags.js';
+import { addMarkdownItems } from './markdown.js';
+import { flattenByProp, getValueFromMdParsedExtension } from '../../utils/index.js';
+import { DEFAULT_WEBHOOKS_TAG_NAME } from '../../constants.js';
+export function buildMenuStructure(parser, options) {
+    const { definition } = parser;
+    const { schemaDefinitionsTagName } = options;
+    const items = [
+        {
+            id: '',
+            name: definition?.info?.['x-seo']?.title || definition?.info?.title || 'Overview',
+            href: '/',
+            depth: 1, // special case for root item,
+            level: 1,
+            type: 'section',
+            infoDefinition: definition.info,
+            items: [],
+        },
+    ];
+    const tags = [...(definition.tags || [])];
+    if (!tags.some((tag) => tag.name === DEFAULT_WEBHOOKS_TAG_NAME)) {
+        tags.push({ name: DEFAULT_WEBHOOKS_TAG_NAME });
+    }
+    const hasAutogenerated = tags.find((tag) => tag?.name === schemaDefinitionsTagName);
+    if (!hasAutogenerated && schemaDefinitionsTagName) {
+        tags.push({ name: schemaDefinitionsTagName });
+    }
+    const tagsMap = getTagsWithOperations(parser, tags);
+    const xTagGroups = definition['x-tagGroups'];
+    items.push(...addMarkdownItems(getValueFromMdParsedExtension(definition.info, 'description') || '', undefined, 1));
+    if (xTagGroups && xTagGroups.length > 0) {
+        items.push(...getTagGroupsItems(parser, undefined, xTagGroups, tagsMap, options));
+    }
+    else {
+        items.push(...getTagsItems(parser, tagsMap, undefined, undefined, options));
+    }
+    return items;
+}
+export function buildContentItems(parser, options) {
+    const contentItems = buildMenuStructure(parser, options);
+    const flatItems = flattenByProp(contentItems || [], 'items');
+    return {
+        contentItems,
+        flatItems,
+    };
+}
+//# sourceMappingURL=builder.js.map

package/lib/services/menu/index.js

@@ -1 +1,2 @@
-import{buildContentItems as o}from"./builder.js";export{o as buildContentItems};
+export { buildContentItems } from './builder.js';
+//# sourceMappingURL=index.js.map

package/lib/services/menu/markdown.js

@@ -1 +1,93 @@
-import h from"@markdoc/markdoc";import{isString as T}from"@redocly/theme/core/openapi";import{getTagOrGroup as d}from"../../models/index.js";import{safeSlugify as y,unescapeHTMLChars as A}from"../../utils/index.js";function x(e,n,a){const i=T(e)?h.parse(e):h.Ast.fromJSON(JSON.stringify(e?.result)),s=[];let o;const l=(t,u,g=s,r,p)=>{t=A(t);let f;r.attributes.id?f=r.attributes.id:(f=p?`${p}/${y(t)}`:`section/${y(t)}`,r.attributes.id=f);const b={id:f.toLowerCase(),name:t,level:u,items:[],ast:[r]};return g.push(b),b},c=(t,u)=>{t[t.length-1]?.ast?.push(u)},m=t=>{const u=C(t)||"",r=n&&n.type==="tag"?n.id:void 0;t.type==="heading"&&t.attributes.level===1?o=l(u,t.attributes.level,void 0,t,r):t.attributes.level?l(u,t.attributes.level,o?.items,t,o?.id??r):o?.items?.length?c(o?.items,t):s?.length&&c(s,t)};if(Array.isArray(i))for(const t of i)m(t);else m(i);return v(n,s,a)}function v(e,n,a=1){return n.map(i=>{const s=d("section",i,e);return s.depth=a,i.items&&(s.items=v(s,i.items,a+1)),s})}function C(e){if(typeof e?.attributes?.content=="string")return e.attributes?.content;if(e?.children)return C(e.children[0])}export{x as addMarkdownItems};
+import markdoc from '@markdoc/markdoc';
+import { isString } from '@redocly/theme/core/openapi';
+import { getTagOrGroup } from '../../models/index.js';
+import { safeSlugify, unescapeHTMLChars } from '../../utils/index.js';
+import { simplifyAstStructure } from '../../utils/simplifyAstStructure.js';
+/**
+ * extracts items from markdown description
+ * @param description - markdown source
+ * @param parent
+ * @param initialDepth - number of items depth
+ */
+export function addMarkdownItems(description, parent, initialDepth) {
+    const ast = isString(description)
+        ? simplifyAstStructure(markdoc.parse(description))
+        : markdoc.Ast.fromJSON(JSON.stringify(description?.result));
+    const items = [];
+    let currentTopHeading;
+    const saveHeading = (name, level, container = items, node, parentId) => {
+        name = unescapeHTMLChars(name);
+        // use custom id or generate id
+        let id;
+        if (node.attributes.id) {
+            id = node.attributes.id;
+        }
+        else {
+            id = parentId ? `${parentId}/${safeSlugify(name)}` : `section/${safeSlugify(name)}`;
+            node.attributes.id = id;
+        }
+        const item = {
+            id: id.toLowerCase(),
+            name,
+            level,
+            items: [],
+            ast: [node],
+        };
+        container.push(item);
+        return item;
+    };
+    const saveContent = (container, node) => {
+        container[container.length - 1]?.ast?.push(node);
+    };
+    const processAst = (node) => {
+        const name = getMarkdownContent(node) || '';
+        // use tag id as prefix instead of just "section" to avoid identical header ids in different tags
+        const isTagContext = parent && parent.type === 'tag';
+        const parentId = isTagContext ? parent.id : undefined;
+        if (node.type === 'heading' && node.attributes.level === 1) {
+            // h1
+            currentTopHeading = saveHeading(name, node.attributes.level, undefined, node, parentId);
+        }
+        else if (node.attributes.level) {
+            // h2, h3, h4 etc
+            saveHeading(name, node.attributes.level, currentTopHeading?.items, node, currentTopHeading?.id ?? parentId);
+        }
+        else {
+            // text, p, etc
+            if (currentTopHeading?.items?.length) {
+                saveContent(currentTopHeading?.items, node);
+            }
+            else if (items?.length) {
+                saveContent(items, node);
+            }
+        }
+    };
+    if (Array.isArray(ast)) {
+        for (const node of ast) {
+            processAst(node);
+        }
+    }
+    else {
+        processAst(ast);
+    }
+    return mapHeadingsDeep(parent, items, initialDepth);
+}
+function mapHeadingsDeep(parent, items, depth = 1) {
+    return items.map((heading) => {
+        const group = getTagOrGroup('section', heading, parent);
+        group.depth = depth;
+        if (heading.items) {
+            group.items = mapHeadingsDeep(group, heading.items, depth + 1);
+        }
+        return group;
+    });
+}
+function getMarkdownContent(node) {
+    if (typeof node?.attributes?.content === 'string') {
+        return node.attributes?.content;
+    }
+    if (node?.children) {
+        return getMarkdownContent(node.children[0]);
+    }
+}
+//# sourceMappingURL=markdown.js.map

package/lib/services/menu/operation.js

@@ -1 +1,50 @@
-import{REDOCLY_TEAMS_RBAC as r}from"@redocly/config";import{encodeBackSlashes as d,getOperationId as c,getOperationName as m}from"../../utils/index.js";function g(o,n,a){if(n.operations.length===0)return[];const p=[],s=[];for(const e of n.operations){const t=c(e,o),i={id:t,type:"operation",parent:o,operationDefinition:e,depth:a,name:m(e),httpVerb:e.httpVerb,path:e.pathName,items:[],isWebhook:e.isWebhook,operationId:e.operationId,badges:e["x-badges"]||[],href:h({id:t}),deprecated:!!e.deprecated,[r]:e[r]||o?.[r]};e.isWebhook?s.push(i):p.push(i)}return[...p.sort((e,t)=>Number(e.deprecated)-Number(t.deprecated)),...s.sort((e,t)=>Number(e.deprecated)-Number(t.deprecated))]}function h({id:o}){return d(`/${o}`.toLowerCase())}export{h as getHref,g as getOperationsItems};
+import { REDOCLY_TEAMS_RBAC } from '@redocly/config';
+import { encodeBackSlashes, getOperationId, getOperationName } from '../../utils/index.js';
+/**
+ * Returns array of Operation items for the tag
+ * @param parent parent OperationsGroup
+ * @param tag tag info returned from `getTagsWithOperations`
+ * @param depth items depth
+ */
+export function getOperationsItems(parent, tag, depth) {
+    if (tag.operations.length === 0) {
+        return [];
+    }
+    const operations = [];
+    const webhooks = [];
+    for (const operationDefinition of tag.operations) {
+        const id = getOperationId(operationDefinition, parent);
+        const type = 'operation';
+        const item = {
+            id,
+            type,
+            parent,
+            operationDefinition,
+            depth,
+            name: getOperationName(operationDefinition),
+            httpVerb: operationDefinition.httpVerb,
+            path: operationDefinition.pathName,
+            items: [],
+            isWebhook: operationDefinition.isWebhook,
+            operationId: operationDefinition.operationId,
+            badges: operationDefinition['x-badges'] || [],
+            href: getHref({ id }),
+            deprecated: !!operationDefinition.deprecated,
+            [REDOCLY_TEAMS_RBAC]: operationDefinition[REDOCLY_TEAMS_RBAC] || parent?.[REDOCLY_TEAMS_RBAC],
+        };
+        if (operationDefinition.isWebhook) {
+            webhooks.push(item);
+        }
+        else {
+            operations.push(item);
+        }
+    }
+    return [
+        ...operations.sort((a, b) => Number(a.deprecated) - Number(b.deprecated)),
+        ...webhooks.sort((a, b) => Number(a.deprecated) - Number(b.deprecated)), // webhooks must be in the end for adding separator
+    ];
+}
+export function getHref({ id }) {
+    return encodeBackSlashes(`/${id}`.toLowerCase());
+}
+//# sourceMappingURL=operation.js.map

package/lib/services/menu/tags.js

@@ -1 +1,166 @@
-import{getTagOrGroup as u}from"../../models/group.js";import{DEFAULT_WEBHOOKS_TAG_NAME as h,GROUP_DEPTH as g}from"../../constants.js";import{getValueFromMdParsedExtension as l,isOperationName as x,JsonPointer as y}from"../../utils/index.js";import{getOperationsItems as T}from"./operation.js";import{addMarkdownItems as O}from"./markdown.js";function b(c,i,s,n,r){let e;if(n===void 0?e=Object.keys(i):e=n.tags,!Array.isArray(e))return console.warn("Unexpected values of tags. Check tags or x-tagGroups in your definition."),[];const f=e.map(t=>i[t]?(i[t].used=!0,i[t]):(console.warn(`Non-existing tag "${t}" is added to the group "${n?.name}"`),null)),a=[];for(const t of f){if(!t)continue;const o=u("tag",t,s);if(o.depth=g+1,t.name===""){const m=[...O(l(t,"description")||"",o,o.depth+1),...T(void 0,t,o.depth+1)];a.push(...m);continue}const p=k({definition:c.definition,tag:t,parent:o,schemaDefinitionsTagName:r.schemaDefinitionsTagName});o.items=[...p,...O(l(t,"description")||"",o,o.depth+1),...T(o,t,o.depth+1)],a.push(o)}return a.filter(({name:t,items:o})=>t!==h||o.length>0)}function G(c,i,s,n,r){const e=[];for(const f of s){const a=u("group",f,i);a.depth=g,a.items=b(c,n,a,f,r),e.push(a)}return e}function k({definition:c,tag:i,parent:s,schemaDefinitionsTagName:n}){const r=n?[n]:[];return Object.entries(c.components?.schemas||{}).map(([e,f])=>{if(!(f["x-tags"]||r).includes(i.name))return null;const t=u("schema",{name:e,"x-displayName":`${f.title||e}`,description:`{% schemaDefinition showWriteOnly="true" schemaRef="#/components/schemas/${e}" /%}`,isSchema:!0,level:2},s);return t.depth=s.depth+1,t}).filter(Boolean)}function I(c,i){const{definition:s}=c,n={},r=s["x-webhooks"]||s.webhooks;for(const e of i||[])n[e.name]={...e,operations:[]};return s.paths&&d(c,s.paths,n),r&&d(c,r,n,!0),n}function d(c,i,s,n){for(const r of Object.keys(i||{})){const e=i[r],f=Object.keys(e).filter(x);for(const a of f){const t=e[a];if(e.$ref){const{resolved:p}=c.deref(e);d(c,{[r]:p},s,n);continue}let o=t?.tags;(!o||!o.length)&&(o=n?[h]:[""]);for(const p of o){let m=s[p];m===void 0&&(m={name:p,operations:[]},s[p]=m),!m["x-traitTag"]&&m.operations.push({...t,pathName:r,pointer:y.compile(["paths",r,a]),httpVerb:a,pathParameters:e.parameters||[],pathServers:e.servers,isWebhook:!!n})}}}}export{G as getTagGroupsItems,b as getTagsItems,I as getTagsWithOperations};
+import { getTagOrGroup } from '../../models/group.js';
+import { DEFAULT_WEBHOOKS_TAG_NAME, GROUP_DEPTH } from '../../constants.js';
+import { getValueFromMdParsedExtension, isOperationName, JsonPointer } from '../../utils/index.js';
+import { getOperationsItems } from './operation.js';
+import { addMarkdownItems } from './markdown.js';
+/**
+ * Returns array of OperationsGroup items for the tags of the group or for all tags
+ * @param parser
+ * @param tagsMap tags info returned from `getTagsWithOperations`
+ * @param parent parent item
+ * @param group group which this tag belongs to. if not provided gets all tags
+ * @param options - normalized options
+ */
+export function getTagsItems(parser, tagsMap, parent, group, options) {
+    let tagNames;
+    if (group === undefined) {
+        tagNames = Object.keys(tagsMap);
+    }
+    else {
+        tagNames = group.tags;
+    }
+    if (!Array.isArray(tagNames)) {
+        console.warn('Unexpected values of tags. Check tags or x-tagGroups in your definition.');
+        return [];
+    }
+    const tags = tagNames.map((tagName) => {
+        if (!tagsMap[tagName]) {
+            console.warn(`Non-existing tag "${tagName}" is added to the group "${group?.name}"`);
+            return null;
+        }
+        tagsMap[tagName].used = true;
+        return tagsMap[tagName];
+    });
+    const res = [];
+    for (const tag of tags) {
+        if (!tag)
+            continue;
+        const item = getTagOrGroup('tag', tag, parent);
+        item.depth = GROUP_DEPTH + 1;
+        // don't put empty tag into content, instead put its operations
+        if (tag.name === '') {
+            const items = [
+                ...addMarkdownItems(getValueFromMdParsedExtension(tag, 'description') || '', item, item.depth + 1),
+                ...getOperationsItems(undefined, tag, item.depth + 1),
+            ];
+            res.push(...items);
+            continue;
+        }
+        const relatedSchemas = getTagRelatedSchema({
+            definition: parser.definition,
+            tag,
+            parent: item,
+            schemaDefinitionsTagName: options.schemaDefinitionsTagName,
+        });
+        item.items = [
+            ...relatedSchemas,
+            ...addMarkdownItems(getValueFromMdParsedExtension(tag, 'description') || '', item, item.depth + 1),
+            ...getOperationsItems(item, tag, item.depth + 1),
+        ];
+        res.push(item);
+    }
+    return res.filter(({ name, items }) => name !== DEFAULT_WEBHOOKS_TAG_NAME || items.length > 0);
+}
+/**
+ * Returns array of OperationsGroup items for the tag groups (x-tagGroups vendor extension)
+ * @param parser
+ * @param parent
+ * @param groups
+ * @param tags value of `x-tagGroups` vendor extension
+ * @param options - normalized options
+ */
+export function getTagGroupsItems(parser, parent, groups, tags, options) {
+    const res = [];
+    for (const group of groups) {
+        const item = getTagOrGroup('group', group, parent);
+        item.depth = GROUP_DEPTH;
+        item.items = getTagsItems(parser, tags, item, group, options);
+        res.push(item);
+    }
+    return res;
+}
+/**
+ * Returns array of schemas with reference to tag, or schemas with reference to schemaDefinitionsTagName tag
+ * @param tagsMap all tags
+ * @param tag tag to find reference of schema
+ * @param schemaDefinitionsTagName config
+ */
+function getTagRelatedSchema({ definition, tag, parent, schemaDefinitionsTagName, }) {
+    const defaultTags = schemaDefinitionsTagName ? [schemaDefinitionsTagName] : [];
+    return Object.entries(definition.components?.schemas || {})
+        .map(([schemaName, schema]) => {
+        const schemaTags = schema['x-tags'] || defaultTags;
+        if (!schemaTags.includes(tag.name))
+            return null;
+        const item = getTagOrGroup('schema', {
+            name: schemaName,
+            'x-displayName': `${schema.title || schemaName}`,
+            description: `{% schemaDefinition showWriteOnly="true" schemaRef="#/components/schemas/${schemaName}" /%}`,
+            isSchema: true,
+            level: 2,
+        }, parent);
+        item.depth = parent.depth + 1;
+        return item;
+    })
+        .filter(Boolean);
+}
+/**
+ * collects tags and maps each tag to list of operations belonging to this tag
+ */
+export function getTagsWithOperations(parser, explicitTags) {
+    const { definition } = parser;
+    const tags = {};
+    const webhooks = definition['x-webhooks'] || definition.webhooks;
+    for (const tag of explicitTags || []) {
+        tags[tag.name] = { ...tag, operations: [] };
+    }
+    if (definition.paths) {
+        getTags(parser, definition.paths, tags);
+    }
+    if (webhooks) {
+        getTags(parser, webhooks, tags, true);
+    }
+    return tags;
+}
+function getTags(parser, paths, tags, isWebhook) {
+    for (const pathName of Object.keys(paths || {})) {
+        const path = paths[pathName];
+        const operations = Object.keys(path).filter(isOperationName);
+        for (const operationName of operations) {
+            const operationInfo = path[operationName];
+            if (path.$ref) {
+                const { resolved: resolvedPaths } = parser.deref(path);
+                getTags(parser, { [pathName]: resolvedPaths }, tags, isWebhook);
+                continue;
+            }
+            let operationTags = operationInfo?.tags;
+            if (!operationTags || !operationTags.length) {
+                // empty tag for operations and default tag for webhooks
+                operationTags = isWebhook ? [DEFAULT_WEBHOOKS_TAG_NAME] : [''];
+            }
+            for (const tagName of operationTags) {
+                let tag = tags[tagName];
+                if (tag === undefined) {
+                    tag = {
+                        name: tagName,
+                        operations: [],
+                    };
+                    tags[tagName] = tag;
+                }
+                if (tag['x-traitTag']) {
+                    continue;
+                }
+                tag.operations.push({
+                    ...operationInfo,
+                    pathName,
+                    pointer: JsonPointer.compile(['paths', pathName, operationName]),
+                    httpVerb: operationName,
+                    pathParameters: path.parameters || [],
+                    pathServers: path.servers,
+                    isWebhook: !!isWebhook,
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=tags.js.map

package/lib/services/types.d.ts

@@ -91,9 +91,6 @@ export interface HooksConfig {
     AfterApiTitle?: HookConfig<{
         info: OpenAPIInfo;
     }>;
-    AfterOpenApiDescription?: HookConfig<{
-        info: OpenAPIInfo;
-    }>;
     BeforeOperation?: HookConfig<{
         operation: OperationModel;
     }>;

package/lib/services/types.js

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

package/lib/services/utils.js

@@ -1 +1,83 @@
-import c from"deepmerge";import{isObject as i}from"@redocly/theme/core/openapi";import{isMergeableObject as u}from"../utils/index.js";function b(e,r){return!e||!r?!1:s(e)===s(r)}function s(e){if(!e)return;const r=e.split(";")[0].toLowerCase(),[t,n]=r.split("/");if(n===void 0)return t;const p=n.split("+").pop();return`${t}/${p}`}function m(e){const r=new RegExp("%7B","g"),t=new RegExp("%7D","g");return e.replace(r,"{").replace(t,"}").replace("///","//").replace("./",".")}function a(e,r){if(!(e.length&&f(e)))return r;const t=e.filter(n=>Object.keys(n).length>0);return r.forEach(function(n,o){u(n)?t[o]=c(e[o],n,{arrayMerge:a}):Array.isArray(n)?t.push(n):t[o]=n}),t}const f=e=>e.some(r=>i(r)&&Object.keys(r).length>0);function w(e){return!!e&&Object.keys(e).length===0}const x=typeof window<"u"&&(window.crypto||window.msCrypto)||void 0;function l(e){if(typeof e!="object"||e===null)return e;const r=Array.isArray(e)?[]:{};for(const t in e){const n=e[t];r[t]=l(n)}return r}export{a as arrayMergeStrategy,x as cryptoLib,l as deepClone,w as isEmptyObject,b as isSameMime,s as normalizeMimeType,m as unescapeServerVariables};
+import merge from 'deepmerge';
+import { isObject } from '@redocly/theme/core/openapi';
+import { isMergeableObject } from '../utils/index.js';
+/**
+ * Compare mime-types ignoring charset or other params (application/json;charset=UTF-8)
+ * @param a
+ * @param b
+ */
+export function isSameMime(a, b) {
+    if (!a || !b)
+        return false;
+    return normalizeMimeType(a) === normalizeMimeType(b);
+}
+/**
+ * Removes the mime-types params e.g. charset (application/json;charset=UTF-8))
+ * Removes any prefixes, e.g. application/hal+json => application/json
+ * Spec is type/subtype;param1=value or type/semantic+format;param1=value
+ * @param mimeType mime type string or undefined
+ */
+export function normalizeMimeType(mimeType) {
+    if (!mimeType)
+        return undefined;
+    const mime = mimeType.split(';')[0].toLowerCase(); // get rid of parameters part
+    const [type, subtype] = mime.split('/');
+    if (subtype === undefined) {
+        return type; // some wrong format, return as is
+    }
+    const subtypeParts = subtype.split('+');
+    const syntax = subtypeParts.pop();
+    return `${type}/${syntax}`;
+}
+export function unescapeServerVariables(str) {
+    // Brackets are escaped in the curl code samples #88
+    // ex.: http://localhost:7700/code-samples-playground?versions#operation/Case-11_1
+    const bracketsOpenReg = new RegExp('%7B', 'g'); // {
+    const bracketsCloseReg = new RegExp('%7D', 'g'); // }
+    return str
+        .replace(bracketsOpenReg, '{')
+        .replace(bracketsCloseReg, '}')
+        .replace('///', '//')
+        .replace('./', '.');
+}
+export function arrayMergeStrategy(target, source) {
+    if (!(target.length && hasObjectOrArray(target))) {
+        return source;
+    }
+    const destination = target.filter((item) => Object.keys(item).length > 0);
+    source.forEach(function (item, index) {
+        if (isMergeableObject(item)) {
+            destination[index] = merge(target[index], item, { arrayMerge: arrayMergeStrategy });
+        }
+        else if (Array.isArray(item)) {
+            destination.push(item);
+        }
+        else {
+            destination[index] = item;
+        }
+    });
+    return destination;
+}
+const hasObjectOrArray = (array) => {
+    return array.some((item) => isObject(item) && Object.keys(item).length > 0);
+};
+export function isEmptyObject(obj) {
+    return !!obj && Object.keys(obj).length === 0;
+}
+export const cryptoLib = (typeof window !== 'undefined' &&
+    (window.crypto || window.msCrypto)) ||
+    undefined;
+export function deepClone(inObject) {
+    if (typeof inObject !== 'object' || inObject === null) {
+        return inObject; // Return the value if inObject is not an object
+    }
+    // Create an array or object to hold the values
+    const outObject = Array.isArray(inObject) ? [] : {};
+    for (const key in inObject) {
+        const value = inObject[key];
+        // Recursively (deep) copy for nested objects, including arrays
+        outObject[key] = deepClone(value);
+    }
+    return outObject;
+}
+//# sourceMappingURL=utils.js.map

package/lib/standalone.js

@@ -1 +1,68 @@
-import{jsx as i}from"react/jsx-runtime";import{createElement as p}from"react";import{createRoot as m,hydrateRoot as u}from"react-dom/client";import{querySelector as s}from"./utils/dom.js";import{RedoclyOpenAPIDocs as l}from"./components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocs.js";import{RedoclyOpenAPIDocsStandalone as f}from"./components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocsStandalone.js";import{setSecurityDetails as v,setSecurityDetailsVariants as O}from"./utils/security-details.js";import{setParameterValue as j}from"./utils/parameters.js";function _(t){const e={},o=t.attributes;for(let r=0;r<o.length;r++){const n=o[r];e[n.name]=n.value}return e}function d(t){const e=_(t),o={};for(const r in e){const n=r.replace(/-(.)/g,(c,a)=>a.toUpperCase());o[n]=e[r]}return o}function N(t,e=document.querySelector("redoc")){u(e,i(l,{store:t}))}function E(t,e={},o=s("redoc")){if(o===null)throw new Error('"element" argument is not provided and <redoc> tag is not found on the page');let r,n;typeof t=="string"?r=t:typeof t=="object"&&(n=t),m(o).render(p(f,{definition:n,definitionUrl:r,options:{...e,...d(o)}},["Loading..."]))}const b=__REDOCLY_API_REFERENCE_VERSION__,h=__REDOCLY_API_REFERENCE_REVISION__;function R(){const t=s("redoc");if(!t)return;const e=t.getAttribute("spec-url");e&&E(e,{},t)}R();export{N as hydrate,E as init,h as revision,j as setParameterValue,v as setSecurityDetails,O as setSecurityDetailsVariants,b as version};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createElement } from 'react';
+import { createRoot, hydrateRoot } from 'react-dom/client';
+import { querySelector } from './utils/dom.js';
+import { RedoclyOpenAPIDocs } from './components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocs.js';
+import { RedoclyOpenAPIDocsStandalone } from './components/RedoclyOpenAPIDocs/RedoclyOpenAPIDocsStandalone.js';
+export { setSecurityDetails, setSecurityDetailsVariants } from './utils/security-details.js';
+export { setParameterValue } from './utils/parameters.js';
+function attributesMap(element) {
+    const res = {};
+    const elAttrs = element.attributes;
+    // tslint:disable-next-line
+    for (let i = 0; i < elAttrs.length; i++) {
+        const attrib = elAttrs[i];
+        res[attrib.name] = attrib.value;
+    }
+    return res;
+}
+function parseOptionsFromElement(element) {
+    const attrMap = attributesMap(element);
+    const res = {};
+    for (const attrName in attrMap) {
+        const optionName = attrName.replace(/-(.)/g, (_, $1) => $1.toUpperCase());
+        res[optionName] = attrMap[attrName];
+        // TODO: normalize options
+    }
+    return res;
+}
+export function hydrate(store, element = document.querySelector('redoc')) {
+    // const store = ProStore.fromJS(state);
+    hydrateRoot(element, _jsx(RedoclyOpenAPIDocs, { store: store }));
+}
+export function init(definitionOrDefinitionUrl, options = {}, element = querySelector('redoc')) {
+    if (element === null) {
+        throw new Error('"element" argument is not provided and <redoc> tag is not found on the page');
+    }
+    let definitionUrl;
+    let definition;
+    if (typeof definitionOrDefinitionUrl === 'string') {
+        definitionUrl = definitionOrDefinitionUrl;
+    }
+    else if (typeof definitionOrDefinitionUrl === 'object') {
+        definition = definitionOrDefinitionUrl;
+    }
+    const root = createRoot(element);
+    root.render(createElement(RedoclyOpenAPIDocsStandalone, {
+        definition,
+        definitionUrl,
+        options: { ...options, ...parseOptionsFromElement(element) },
+    }, ['Loading...']));
+}
+export const version = __REDOCLY_API_REFERENCE_VERSION__;
+export const revision = __REDOCLY_API_REFERENCE_REVISION__;
+/**
+ * autoinit ReDoc if <redoc> tag is found on the page with "spec-url" attr
+ */
+function autoInit() {
+    const element = querySelector('redoc');
+    if (!element) {
+        return;
+    }
+    const specUrl = element.getAttribute('spec-url');
+    if (specUrl) {
+        init(specUrl, {}, element);
+    }
+}
+autoInit();
+//# sourceMappingURL=standalone.js.map

package/lib/styled-components.js

@@ -1 +1,6 @@
-import t from"styled-components";const e=typeof t=="function"?t:t.default;export{e as styled};
+import _styled from 'styled-components';
+// https://github.com/styled-components/styled-components/issues/3601#issue-1023120934
+export const styled = 
+// @ts-expect-error incompatibility between styled-components and @types/styled-components
+typeof _styled === 'function' ? _styled : _styled.default;
+//# sourceMappingURL=styled-components.js.map

package/lib/types/app.js

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

package/lib/types/index.js

@@ -1 +1,4 @@
-export*from"./open-api.js";export*from"./security.js";export*from"./app.js";
+export * from './open-api.js';
+export * from './security.js';
+export * from './app.js';
+//# sourceMappingURL=index.js.map

package/lib/types/open-api.d.ts

@@ -105,6 +105,7 @@ export interface OpenAPIOperation extends ParsedDescriptionWithSummary {
     'x-codeSamples'?: OpenAPIXCodeSample[];
     'x-badges'?: OpenAPIXBadges[];
     'x-hideReplay'?: boolean;
+    'x-owner-key'?: string;
 }
 export interface OpenAPIParameter extends ParsedDescription {
     name: string;