@stainless-api/docs-ui 0.1.0-beta.10 → 0.1.0-beta.11

package/dist/languages/ruby.js

@@ -1,125 +1,16 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import * as React from 'react';
-import { useDeclaration, useLanguage, useLanguageComponents, useSpec } from '../contexts';
-import { useComponents } from '../contexts/use-components';
-import style from '../style';
-const ComplexTypes = {
-    RubyTypeObject: 'object',
-    RubyTypeUnion: 'union',
-    RubyTypeIntersection: 'intersection',
-    RubyTypeArray: 'array',
-    RubyTypeMap: 'hash',
-};
-const Keywords = {
-    RubyTypeBinary: 'StringIO',
-    RubyTypeUnknown: 'untyped',
-    RubyTypeNull: 'nil',
-    RubyTypeInteger: 'Integer',
-    RubyTypeFloat: 'Float',
-    RubyTypeBoolean: 'bool',
-};
-export function TypeName({ type }) {
-    const Lang = useLanguageComponents();
-    return ComplexTypes[type.kind] ?? _jsx(Lang.Type, { type: type });
-}
-const VALID_IDENTIFIER = /^[_A-Za-z][_A-Za-z0-9]*$/;
-function TypePreview({ path }) {
-    const spec = useSpec();
-    const language = useLanguage();
-    const decl = useDeclaration(path);
-    const { Join } = useComponents();
-    if (!(decl && 'children' in decl && decl.children.length > 0) || decl['type']?.['kind'] === 'RubyTypeUnion')
-        return;
-    const items = decl.children.map((prop, key) => (_jsx("span", { className: style.TypePropertyName, children: _jsx("span", { className: style.TextIdentifier, children: spec?.decls?.[language]?.[prop]?.['ident'] }) }, key)));
-    return (_jsxs("span", { className: style.TypePreview, "data-stldocs-type-preview": "properties", children: [_jsx("span", { className: style.TypeBrace, children: ' {' }), _jsxs("span", { className: style.TypePreviewContent, children: [' ', _jsx(Join, { items: items, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), ' '] }), _jsx("span", { className: style.TypeBrace, children: '} ' })] }));
-}
-export function Type({ type }) {
-    const Lang = useLanguageComponents();
-    const { SDKReference, Join } = useComponents();
-    switch (type.kind) {
-        case 'RubyTypeBinary':
-        case 'RubyTypeUnknown':
-        case 'RubyTypeNull':
-        case 'RubyTypeInteger':
-        case 'RubyTypeFloat':
-        case 'RubyTypeBoolean':
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypeKeyword, children: Keywords[type.kind] }) }));
-        case 'RubyTypeString':
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypeString, children: "String" }) }));
-        case 'RubyTypeLiteral':
-            switch (typeof type.literal) {
-                case 'string':
-                    return (_jsx("span", { className: style.Type, children: _jsxs("span", { className: style.LiteralString, children: [':', type.literal.match(VALID_IDENTIFIER) ? type.literal : JSON.stringify(type.literal)] }) }));
-                case 'number':
-                    return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.LiteralNumeric, children: JSON.stringify(type.literal) }) }));
-                case 'boolean':
-                    return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.LiteralBoolean, children: JSON.stringify(type.literal) }) }));
-            }
-        case 'RubyTypeArray':
-            return (_jsxs("span", { className: style.Type, children: [_jsx("span", { className: style.TypeArray, children: 'Array[' }), _jsx(Lang.Type, { type: type.elementType }), _jsx("span", { className: style.TypeArray, children: ']' })] }));
-        case 'RubyTypeMap':
-            return (_jsxs("span", { className: style.Type, children: [_jsx("span", { className: style.TypeArray, children: 'Hash[' }), type.indexType.kind === 'RubyTypeString' ? (_jsx("span", { className: style.TypeString, children: "Symbol" })) : (_jsx(Lang.Type, { type: type.indexType })), ", ", _jsx(Lang.Type, { type: type.itemType }), _jsx("span", { className: style.TypeArray, children: ']' })] }));
-        case 'RubyTypeReference': {
-            const name = type.ident.split('.').at(-1);
-            if (!type.typeParameters || type.typeParameters.length === 0)
-                return (_jsxs("span", { className: style.Type, children: [_jsx(SDKReference, { stainlessPath: type.$ref, children: name }), _jsx(TypePreview, { path: type.$ref })] }));
-            const typeParameters = type.typeParameters.map((t, i) => _jsx(Lang.Type, { type: t }, i));
-            return (_jsxs("span", { className: style.Type, children: [_jsx(SDKReference, { stainlessPath: type.$ref, children: name }), _jsx("span", { className: style.TypeBracket, children: '<' }), _jsx(Join, { items: typeParameters, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), _jsx("span", { className: style.TypeBracket, children: '>' }), _jsx(TypePreview, { path: type.$ref })] }));
-        }
-        case 'RubyTypeIntersection':
-        case 'RubyTypeUnion': {
-            const items = type.types.map((t, key) => _jsx(Lang.Type, { type: t }, key));
-            const delimiter = type.kind === 'RubyTypeUnion' ? '|' : '&';
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypePreview, "data-stldocs-type-preview": "union", children: _jsx("span", { className: style.TypePreviewContent, children: _jsx(Join, { items: items, limit: 3, children: _jsxs("span", { className: style.TextOperator, children: [" ", delimiter, " "] }) }) }) }) }));
-        }
-        case 'RubyTypeBuiltinClass':
-            return _jsx("span", { className: style.TypeReference, children: type.className });
-        case 'RubyTypeObject': {
-            const items = type.members.map((prop, key) => (_jsx("span", { className: style.TextIdentifier, children: prop.ident }, key)));
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypePreview, "data-stldocs-type-preview": "properties", children: _jsxs("span", { className: style.TypePreviewContent, children: [_jsx("span", { className: style.TypeBrace, children: '{ ' }), _jsx(Join, { items: items, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), _jsx("span", { className: style.TypeBrace, children: '}' })] }) }) }));
-        }
-    }
-}
-export function MethodSignature({ decl }) {
-    const Lang = useLanguageComponents();
-    const { Join } = useComponents();
-    const params = decl.args.map((param, i) => (_jsx(React.Fragment, { children: _jsx("span", { className: style.TextIdentifier, children: param.ident }) }, i)));
-    return (_jsx("div", { className: style.MethodSignature, children: _jsxs("span", { className: style.SignatureTitle, children: [_jsx("span", { className: style.SignatureQualified, children: _jsx("span", { className: style.TextIdentifier, children: decl.qualified?.slice(0, -decl.ident.length) }) }), _jsx("span", { className: style.SignatureName, children: _jsx("span", { className: style.TextIdentifier, children: decl.ident }) }), _jsxs("span", { className: style.MethodSignature, children: [_jsx("span", { className: style.SignatureParen, children: '(' }), _jsx("span", { className: style.SignatureParams, children: _jsx(Join, { items: params, children: _jsx("span", { className: style.TextOperator, children: ', ' }) }) }), _jsx("span", { className: style.SignatureParen, children: ')' }), ' -> ', decl.returns ? _jsx(Lang.Type, { type: decl.returns }) : 'void'] })] }) }));
-}
-export function Property({ decl, children }) {
-    const Lang = useLanguageComponents();
-    switch (decl.kind) {
-        case 'RubyDeclProperty':
-            return children({
-                name: decl.ident,
-                typeName: _jsx(Lang.TypeName, { type: decl.type }),
-                type: decl.type.kind in ComplexTypes && _jsx(Lang.Type, { type: decl.type }),
-            });
-        case 'RubyDeclTypeAlias':
-            return children({
-                name: decl.ident,
-                typeName: 'alias',
-                type: _jsx(Lang.Type, { type: decl.type }),
-            });
-        case 'RubyDeclReference':
-            return children({ type: _jsx(Lang.Type, { type: decl.type }) });
-        case 'RubyDeclClass':
-            return children({ name: decl.ident, typeName: 'class' });
-    }
-}
-export function Declaration({ decl }) {
-    const Lang = useLanguageComponents();
-    if (!decl)
-        return;
-    switch (decl.kind) {
-        case 'RubyDeclProperty':
-            return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TypePropertyName, children: _jsx("span", { className: style.TextIdentifier, children: decl.ident }) }), _jsx("span", { className: style.TextPunctuation, children: ": " }), _jsx(Lang.Type, { type: decl.type })] }));
-        case 'RubyDeclTypeAlias':
-            return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextIdentifier, children: decl.ident }), _jsx("span", { className: style.TextOperator, children: " = " }), _jsx(Lang.Type, { type: decl.type })] }));
-        case 'RubyDeclClass':
-            return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: "class " }), _jsx("span", { className: style.TextIdentifier, children: decl.ident }), _jsx(TypePreview, { path: decl.stainlessPath })] }));
-        case 'RubyDeclReference':
-            return _jsx(Lang.Type, { type: decl.type });
-    }
-}
-//# sourceMappingURL=ruby.js.map
+import "../component-generics-DzI21jRn.js";
+import "../docs-Dh8kE1va.js";
+import "../navigation-aoYZ_tl4.js";
+import "../markdown-BXfX1D7C.js";
+import "../routing-DQjbRxdJ.js";
+import "../style-rYbbxIR_.js";
+import "../use-components-D9E85p5x.js";
+import { D as Property, E as MethodSignature, O as Type, T as Declaration, k as TypeName } from "../contexts-DRxRO-xO.js";
+import "../icons-DdKM-01E.js";
+import "../utils-CJfFBNgT.js";
+import "../dropdown-DtgAi6lb.js";
+import "../md-Dg8aOyMA.js";
+import "../utils-BHwvUDKn.js";
+import "../types-DFN4M1Sp.js";
+
+export { Declaration, MethodSignature, Property, Type, TypeName };

package/dist/languages/typescript.d.ts

@@ -1,22 +1,13 @@
-import * as React from 'react';
-import type { TypeScriptAST as TSAST } from '../types/sdkjson';
-import { PropertyFn } from '.';
-type TypeProps = {
-    type: TSAST.TSType;
-};
-export declare function TypeName({ type }: TypeProps): string | import("react/jsx-runtime").JSX.Element;
-export declare function Type({ type }: TypeProps): import("react/jsx-runtime").JSX.Element;
-export type MethodSignatureProps = {
-    decl: TSAST.TSDeclFunction;
-};
-export declare function MethodSignature({ decl }: MethodSignatureProps): import("react/jsx-runtime").JSX.Element;
-export type PropertyProps = {
-    decl: TSAST.TSDeclaration;
-    children?: PropertyFn;
-};
-export declare function Property({ decl, children }: PropertyProps): React.ReactNode;
-export type DeclarationProps = {
-    decl: TSAST.TSDeclaration;
-};
-export declare function Declaration({ decl }: DeclarationProps): import("react/jsx-runtime").JSX.Element | undefined;
-export {};
+import "../breadcrumbs-Z-hEqjcp.js";
+import "../dropdown-B7VyGMOw.js";
+import "../method-DpsVuzZW.js";
+import "../primitives-DWz23_Ub.js";
+import "../properties-CF71V58d.js";
+import "../routing-qc0V00-j.js";
+import "../sdk-Zg3Rggk3.js";
+import "../snippets-EUzM4fRO.js";
+import "../overview-C8e-6jGr.js";
+import "../sidebar-C8KirYjg.js";
+import "../index-YnpUtXLB.js";
+import { $ as Declaration, at as Type, et as DeclarationProps, it as PropertyProps, nt as MethodSignatureProps, ot as TypeName, rt as Property, tt as MethodSignature } from "../index-AicgPYKB.js";
+export { Declaration, DeclarationProps, MethodSignature, MethodSignatureProps, Property, PropertyProps, Type, TypeName };

package/dist/languages/typescript.js

@@ -1,134 +1,16 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import * as React from 'react';
-import { useDeclaration, useLanguage, useLanguageComponents, useSpec } from '../contexts';
-import { useComponents } from '../contexts/use-components';
-import style from '../style';
-const ComplexTypes = {
-    TSTypeObject: 'object',
-    TSTypeUnion: 'union',
-    TSTypeInterface: 'interface',
-    TSTypeIntersection: 'intersection',
-    TSTypeArray: 'array',
-};
-const constStyle = {
-    string: style.LiteralString,
-    number: style.LiteralNumeric,
-    boolean: style.LiteralBoolean,
-};
-function Identifier({ name, optional }) {
-    return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextIdentifier, children: /^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) ? name : JSON.stringify(name) }), optional && _jsx("span", { className: style.TextPunctuation, children: "?" })] }));
-}
-function TypeParams({ params }) {
-    const Lang = useLanguageComponents();
-    const { Join } = useComponents();
-    if (!params?.length)
-        return null;
-    const typeParams = params?.map((param, key) => param.constraint ? (_jsxs(React.Fragment, { children: [_jsx("span", { className: style.TypeReference, children: param.name }), _jsx("span", { className: style.TextKeyword, children: "extends " }), _jsx(Lang.Type, { type: param.constraint })] }, key)) : (_jsx(React.Fragment, { children: "param.name" }, key)));
-    return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TypeBracket, children: '<' }), _jsx(Join, { items: typeParams, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), _jsx("span", { className: style.TypeBracket, children: '>' })] }));
-}
-function TypePreview({ path }) {
-    const spec = useSpec();
-    const language = useLanguage();
-    const decl = useDeclaration(path);
-    const { Join } = useComponents();
-    if (!(decl && 'children' in decl && decl.children.length > 0) || decl['type']?.['kind'] === 'TSTypeUnion')
-        return;
-    const items = decl.children.map((prop, key) => (_jsx("span", { className: style.TypePropertyName, children: _jsx("span", { className: style.TextIdentifier, children: spec?.decls?.[language]?.[prop]?.['key'] }) }, key)));
-    return (_jsxs("span", { className: style.TypePreview, "data-stldocs-type-preview": "properties", children: [_jsx("span", { className: style.TypeBrace, children: ' {' }), _jsxs("span", { className: style.TypePreviewContent, children: [' ', _jsx(Join, { items: items, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), ' '] }), _jsx("span", { className: style.TypeBrace, children: '} ' })] }));
-}
-export function TypeName({ type }) {
-    const Lang = useLanguageComponents();
-    return ComplexTypes[type.kind] ?? _jsx(Lang.Type, { type: type });
-}
-export function Type({ type }) {
-    const Lang = useLanguageComponents();
-    const { Join, SDKReference } = useComponents();
-    switch (type.kind) {
-        case 'TSTypeUnknown':
-        case 'TSTypeUndefined':
-        case 'TSTypeNever':
-        case 'TSTypeVoid':
-        case 'TSTypeNull':
-        case 'TSTypeAny':
-        case 'TSTypeBoolean':
-        case 'TSTypeNumber':
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypeKeyword, children: type.kind.slice(6).toLowerCase() }) }));
-        case 'TSTypeString':
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypeString, children: "string" }) }));
-        case 'TSTypeLiteral':
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: constStyle[typeof type.literal], children: JSON.stringify(type.literal) }) }));
-        case 'TSTypeArray': {
-            return (_jsxs("span", { className: style.Type, children: [_jsx("span", { className: style.TypeArray, children: 'Array<' }), _jsx(Lang.Type, { type: type.elementType }), _jsx("span", { className: style.TypeArray, children: '>' })] }));
-        }
-        case 'TSTypeReference': {
-            const name = type.ident.split('.').at(-1);
-            const params = type.typeParameters?.map((param, key) => _jsx(Lang.Type, { type: param }, key));
-            return (_jsxs("span", { className: style.Type, children: [_jsx(SDKReference, { stainlessPath: type.$ref, children: name }), params && params.length > 0 && (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TypeBracket, children: '<' }), _jsx(Join, { items: params, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }), _jsx("span", { className: style.TypeBracket, children: '>' })] })), _jsx(TypePreview, { path: type.$ref })] }));
-        }
-        case 'TSTypeIntersection':
-        case 'TSTypeUnion': {
-            const items = type.types.map((t, key) => _jsx(Lang.Type, { type: t }, key));
-            const delimiter = type.kind === 'TSTypeUnion' ? '|' : '&';
-            return (_jsx("span", { className: style.Type, children: _jsx("span", { className: style.TypePreview, "data-stldocs-type-preview": "union", children: _jsx("span", { className: style.TypePreviewContent, children: _jsx(Join, { items: items, limit: 3, children: _jsxs("span", { className: style.TextOperator, children: [" ", delimiter, " "] }) }) }) }) }));
-        }
-        case 'TSTypeObject':
-        case 'TSTypeInterface': {
-            const extend = type.kind === 'TSTypeObject'
-                ? null
-                : type.extends?.map((ref, key) => _jsx(Lang.Type, { type: ref }, key));
-            const items = type.members.map((prop, key) => (_jsxs(React.Fragment, { children: [_jsx("span", { className: style.TypePropertyName, children: _jsx(Identifier, { name: prop.ident, optional: prop.optional }) }), _jsx("span", { className: style.TextPunctuation, children: ": " }), _jsx(Lang.Type, { type: prop.type })] }, key)));
-            return (_jsxs("span", { className: style.Type, children: [extend?.length && (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TypeKeyword, children: " extends " }), _jsx(Join, { items: extend, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) })] })), _jsxs("span", { className: style.TypePreview, "data-stldocs-type-preview": "properties", children: [_jsx("span", { className: style.TypeBrace, children: '{ ' }), _jsx("span", { className: style.TypePreviewContent, children: _jsx(Join, { items: items, limit: 3, children: _jsx("span", { className: style.TextOperator, children: ", " }) }) }), _jsx("span", { className: style.TypeBrace, children: '} ' })] })] }));
-        }
-    }
-}
-export function MethodSignature({ decl }) {
-    const Lang = useLanguageComponents();
-    const { Join, Tooltip } = useComponents();
-    const params = decl.signature.parameters.map((param, i) => (_jsxs(React.Fragment, { children: [_jsx(Tooltip, { content: _jsx(Lang.Type, { type: param.type }), children: _jsx("span", { className: style.TextIdentifier, children: param.ident }) }), param.optional && _jsx("span", { className: style.TextPunctuation, children: "?" })] }, i)));
-    return (_jsx("div", { className: style.MethodSignature, children: _jsxs("span", { className: style.SignatureTitle, children: [decl.signature.async && _jsx("span", { className: style.TextKeyword, children: "async " }), _jsx("span", { className: style.SignatureQualified, children: _jsx("span", { className: style.TextIdentifier, children: decl.qualified?.slice(0, -decl.ident.length) }) }), _jsx("span", { className: style.SignatureName, children: _jsx("span", { className: style.TextIdentifier, children: decl.ident }) }), _jsxs("span", { className: style.MethodSignature, children: [decl.signature.typeParameters && _jsx(TypeParams, { params: decl.signature.typeParameters }), _jsx("span", { className: style.SignatureParen, children: '(' }), _jsx("span", { className: style.SignatureParams, children: _jsx(Join, { items: params, children: _jsx("span", { className: style.TextOperator, children: ', ' }) }) }), _jsx("span", { className: style.SignatureParen, children: ')' }), decl.signature.returns && (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextPunctuation, children: ": " }), _jsx(Lang.Type, { type: decl.signature.returns })] }))] })] }) }));
-}
-export function Property({ decl, children }) {
-    const Lang = useLanguageComponents();
-    if (!decl)
-        return;
-    switch (decl.kind) {
-        case 'TSDeclProperty':
-            return children({
-                name: decl.key,
-                typeName: _jsx(Lang.TypeName, { type: decl.type }),
-                type: decl.type.kind in ComplexTypes && _jsx(Lang.Type, { type: decl.type }),
-            });
-        case 'TSDeclTypeAlias':
-            return children({
-                name: decl.ident,
-                typeName: 'alias',
-                type: _jsx(Lang.Type, { type: decl.type }),
-            });
-        case 'TSDeclReference':
-            return children({ type: _jsx(Lang.Type, { type: decl.type }) });
-        case 'TSDeclInterface':
-            return children({
-                type: (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextIdentifier, children: decl.ident }), decl.typeParameters && _jsx(TypeParams, { params: decl.typeParameters }), decl.extends?.flatMap((t, key) => (_jsxs(React.Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: " extends " }), _jsx(Lang.Type, { type: t })] }, `extends:${key}`)))] })),
-            });
-    }
-}
-export function Declaration({ decl }) {
-    const Lang = useLanguageComponents();
-    if (!decl)
-        return;
-    switch (decl.kind) {
-        case 'TSDeclProperty':
-            return (_jsxs(_Fragment, { children: [decl.declare && _jsx("span", { className: style.TextKeyword, children: "declare " }), _jsx("span", { className: style.TypePropertyName, children: _jsx(Identifier, { name: decl.key, optional: decl.optional }) }), _jsx("span", { className: style.TextPunctuation, children: ": " }), _jsx(Lang.Type, { type: decl.type })] }));
-        case 'TSDeclFunction':
-            return _jsx(Lang.MethodSignature, { decl: decl });
-        case 'TSDeclTypeAlias':
-            return (_jsxs(_Fragment, { children: [_jsx(Identifier, { name: decl.ident }), _jsx(TypeParams, { params: decl.typeParameters }), _jsx("span", { className: style.TextOperator, children: " = " }), _jsx(Lang.Type, { type: decl.type })] }));
-        case 'TSDeclReference':
-            return _jsx(Lang.Type, { type: decl.type });
-        case 'TSDeclInterface':
-            return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextIdentifier, children: decl.ident }), _jsx(TypeParams, { params: decl.typeParameters }), decl.extends?.map((t, index) => (_jsxs(React.Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: " extends " }), _jsx(Lang.Type, { type: t })] }, index))), _jsx(TypePreview, { path: decl.stainlessPath })] }));
-        case 'TSDeclClass':
-            return (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: "class " }), _jsx("span", { className: style.TextIdentifier, children: decl.ident }), _jsx(TypeParams, { params: decl.typeParameters }), decl.superClass ? (_jsxs(_Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: " extends " }), _jsx(Lang.Type, { type: decl.superClass })] })) : null, decl.implements?.map((t, index) => (_jsxs(React.Fragment, { children: [_jsx("span", { className: style.TextKeyword, children: " implements " }), _jsx(Lang.Type, { type: t })] }, index)))] }));
-    }
-}
-//# sourceMappingURL=typescript.js.map
+import "../component-generics-DzI21jRn.js";
+import "../docs-Dh8kE1va.js";
+import "../navigation-aoYZ_tl4.js";
+import "../markdown-BXfX1D7C.js";
+import "../routing-DQjbRxdJ.js";
+import "../style-rYbbxIR_.js";
+import "../use-components-D9E85p5x.js";
+import { $ as TypeName, Q as Type, X as MethodSignature, Y as Declaration, Z as Property } from "../contexts-DRxRO-xO.js";
+import "../icons-DdKM-01E.js";
+import "../utils-CJfFBNgT.js";
+import "../dropdown-DtgAi6lb.js";
+import "../md-Dg8aOyMA.js";
+import "../utils-BHwvUDKn.js";
+import "../types-DFN4M1Sp.js";
+
+export { Declaration, MethodSignature, Property, Type, TypeName };

package/dist/markdown/index.d.ts

@@ -1,6 +1,11 @@
-import { EnvironmentType } from './utils';
-import type { SDKJSON } from '../types/sdkjson';
-import type { Node } from '@markdoc/markdoc';
-export declare function declaration(env: EnvironmentType, decl: SDKJSON.DeclarationNode): Node;
-export declare function render(env: EnvironmentType, node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model): any;
-export declare function renderMarkdown(env: EnvironmentType, node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model): string;
+import "../routing-qc0V00-j.js";
+import "../sdk-Zg3Rggk3.js";
+import { t as EnvironmentType } from "../utils-DQhEbvUC.js";
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/index.d.ts
+declare function declaration(env: EnvironmentType, decl: SDKJSON.DeclarationNode): Node;
+declare function render(env: EnvironmentType, node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model): any;
+declare function renderMarkdown(env: EnvironmentType, node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model): string;
+//#endregion
+export { declaration, render, renderMarkdown };

package/dist/markdown/index.js

@@ -1,80 +1,16 @@
-import Markdoc from '@markdoc/markdoc';
-import * as md from './md';
-import { getDecl, getSnippet, stripMarkup } from './utils';
-import * as printer from '../search/printer';
-export function declaration(env, decl) {
-    const content = printer.declaration(env.language, decl);
-    return md.paragraph(md.code(stripMarkup(content)));
-}
-function renderChildren(env, children, nesting = []) {
-    return md.list(...children.map((child) => renderDecl(env, child, nesting)));
-}
-function renderDecl(env, path, nesting = []) {
-    const decl = getDecl(env, path);
-    const item = md.item(declaration(env, decl));
-    const hasChildren = 'children' in decl && decl.children.length > 0;
-    const showModelProps = !decl['modelPath'] || env.options.includeModelProperties;
-    if ('docstring' in decl && decl.docstring)
-        item.children.push(...md.parse(decl.docstring));
-    if (hasChildren && showModelProps && !nesting.includes(path))
-        item.push(renderChildren(env, decl.children, [...nesting, path]));
-    return item;
-}
-function renderMethod(env, method) {
-    const decl = getDecl(env, method.stainlessPath);
-    if (!decl)
-        return [
-            md.paragraph(md.text('The method '), md.code(method.name), md.text(' is not available in this language.')),
-        ];
-    const signature = printer.methodSignature(env.language, decl);
-    const [httpMethod, endpoint] = method.endpoint.split(' ');
-    const output = [
-        md.heading(2, method.title),
-        env.language === 'http' ? null : md.paragraph(md.code(stripMarkup(signature))),
-        md.paragraph(md.strong(md.text(httpMethod)), md.text(' '), md.code(endpoint)),
-    ];
-    if (method.description)
-        output.push(...md.parse(method.description));
-    if ('paramsChildren' in decl && Array.isArray(decl.paramsChildren) && decl.paramsChildren.length > 0)
-        output.push(md.heading(3, 'Parameters'), renderChildren(env, decl.paramsChildren));
-    if ('responseChildren' in decl && decl.responseChildren.length > 0)
-        output.push(md.heading(3, 'Returns'), renderChildren(env, decl.responseChildren));
-    const snippet = getSnippet(env, method.stainlessPath);
-    if (snippet)
-        output.push(md.heading(3, 'Example'), md.fence(env.language, snippet));
-    return output;
-}
-function renderModel(env, model) {
-    return [md.heading(3, model.title), md.list(renderDecl(env, `${model.stainlessPath} > (schema)`))];
-}
-function renderResource(env, resource) {
-    const methods = Object.values(resource.methods)
-        .filter((method) => getDecl(env, method.stainlessPath))
-        .flatMap((method) => renderMethod(env, method));
-    const models = Object.values(resource.models)
-        .filter((model) => getDecl(env, `${model.stainlessPath} > (schema)`))
-        .flatMap((model) => renderModel(env, model));
-    const doc = [md.heading(1, resource.title), ...methods];
-    if (models.length > 0)
-        doc.push(md.heading(2, 'Domain Types'), ...models);
-    if (!env.options.renderNestedResources)
-        return doc;
-    const children = Object.values(resource.subresources).map((resource) => renderResource(env, resource));
-    return [...doc, ...children];
-}
-export function render(env, node) {
-    switch (node.kind) {
-        case 'resource':
-            return renderResource(env, node);
-        case 'http_method':
-            return renderMethod(env, node);
-        case 'model':
-            return renderModel(env, node);
-    }
-}
-export function renderMarkdown(env, node) {
-    const content = render(env, node);
-    const doc = new Markdoc.Ast.Node('document', {}, content);
-    return Markdoc.format(doc);
-}
-//# sourceMappingURL=index.js.map
+import "../component-generics-DzI21jRn.js";
+import "../docs-Dh8kE1va.js";
+import "../navigation-aoYZ_tl4.js";
+import "../markdown-BXfX1D7C.js";
+import "../routing-DQjbRxdJ.js";
+import "../style-rYbbxIR_.js";
+import "../use-components-D9E85p5x.js";
+import { d as render, f as renderMarkdown, u as declaration } from "../contexts-DRxRO-xO.js";
+import "../icons-DdKM-01E.js";
+import "../utils-CJfFBNgT.js";
+import "../dropdown-DtgAi6lb.js";
+import "../md-Dg8aOyMA.js";
+import "../utils-BHwvUDKn.js";
+import "../types-DFN4M1Sp.js";
+
+export { declaration, render, renderMarkdown };

package/dist/markdown/md.d.ts

@@ -1,11 +1,15 @@
-import type { Node } from '@markdoc/markdoc';
-export declare function heading(level: number, children: string | Node[]): Node;
-export declare function text(content: string): Node;
-export declare function code(content: string): Node;
-export declare function paragraph(...children: Node[]): Node;
-export declare function list(...children: Node[]): Node;
-export declare function item(...children: Node[]): Node;
-export declare function strong(...children: Node[]): Node;
-export declare function inline(...children: Node[]): Node;
-export declare function fence(language: string, content: string): Node;
-export declare function parse(content: string): Node[];
+import { Node } from "@markdoc/markdoc";
+
+//#region src/markdown/md.d.ts
+declare function heading(level: number, children: string | Node[]): Node;
+declare function text(content: string): Node;
+declare function code(content: string): Node;
+declare function paragraph(...children: Node[]): Node;
+declare function list(...children: Node[]): Node;
+declare function item(...children: Node[]): Node;
+declare function strong(...children: Node[]): Node;
+declare function inline(...children: Node[]): Node;
+declare function fence(language: string, content: string): Node;
+declare function parse(content: string): Node[];
+//#endregion
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/md.js

@@ -1,34 +1,3 @@
-import Markdoc from '@markdoc/markdoc';
-export function heading(level, children) {
-    const content = inline(...(typeof children === 'string' ? [text(children)] : children));
-    return new Markdoc.Ast.Node('heading', { level }, [content]);
-}
-export function text(content) {
-    return new Markdoc.Ast.Node('text', { content });
-}
-export function code(content) {
-    return new Markdoc.Ast.Node('code', { content });
-}
-export function paragraph(...children) {
-    const inline = new Markdoc.Ast.Node('inline', {}, children);
-    return new Markdoc.Ast.Node('paragraph', {}, [inline]);
-}
-export function list(...children) {
-    return new Markdoc.Ast.Node('list', { ordered: false }, children);
-}
-export function item(...children) {
-    return new Markdoc.Ast.Node('item', {}, children);
-}
-export function strong(...children) {
-    return new Markdoc.Ast.Node('strong', {}, children);
-}
-export function inline(...children) {
-    return new Markdoc.Ast.Node('inline', {}, children);
-}
-export function fence(language, content) {
-    return new Markdoc.Ast.Node('fence', { language, content });
-}
-export function parse(content) {
-    return Markdoc.parse(content).children;
-}
-//# sourceMappingURL=md.js.map
+import { a as item, c as parse, i as inline, l as strong, n as fence, o as list, r as heading, s as paragraph, t as code, u as text } from "../md-Dg8aOyMA.js";
+
+export { code, fence, heading, inline, item, list, paragraph, parse, strong, text };

package/dist/markdown/utils.d.ts

@@ -1,17 +1,4 @@
-import type { DocsLanguage } from '../routing';
-import type { SDKJSON } from '../types/sdkjson';
-import type { TransformRequestSnippetFn } from '../components/sdk';
-export type EnvironmentType = {
-    spec: SDKJSON.Spec;
-    language: DocsLanguage;
-    transforms?: {
-        transformRequestSnippet?: TransformRequestSnippetFn;
-    };
-    options: {
-        renderNestedResources?: boolean;
-        includeModelProperties?: boolean;
-    };
-};
-export declare function getDecl(env: EnvironmentType, path: string): any;
-export declare function getSnippet(env: EnvironmentType, path: string): any;
-export declare function stripMarkup(content: string): string;
+import "../routing-qc0V00-j.js";
+import "../sdk-Zg3Rggk3.js";
+import { i as stripMarkup, n as getDecl, r as getSnippet, t as EnvironmentType } from "../utils-DQhEbvUC.js";
+export { EnvironmentType, getDecl, getSnippet, stripMarkup };

package/dist/markdown/utils.js

@@ -1,30 +1,3 @@
-import { Parser } from 'htmlparser2';
-export function getDecl(env, path) {
-    const decl = env.spec?.decls?.[env.language]?.[path];
-    if (decl?.kind?.endsWith('Reference')) {
-        const refId = decl['type']['$ref'];
-        if (refId === path)
-            return decl;
-        if (refId)
-            return getDecl(env, refId);
-    }
-    return decl;
-}
-export function getSnippet(env, path) {
-    let snippet = env.spec?.snippets?.[`${env.language}.default`]?.[path];
-    if (typeof snippet === 'string' && env.transforms?.transformRequestSnippet) {
-        snippet = env.transforms.transformRequestSnippet({ snippet, language: env.language });
-    }
-    return snippet;
-}
-export function stripMarkup(content) {
-    let output = '';
-    const parser = new Parser({
-        ontext(content) {
-            output += content;
-        },
-    });
-    parser.parseComplete(content);
-    return output;
-}
-//# sourceMappingURL=utils.js.map
+import { n as getSnippet, r as stripMarkup, t as getDecl } from "../utils-BHwvUDKn.js";
+
+export { getDecl, getSnippet, stripMarkup };

package/dist/markdown-BXfX1D7C.js

@@ -0,0 +1,42 @@
+import { a as useLanguage } from "./docs-Dh8kE1va.js";
+import * as React$1 from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/contexts/markdown.tsx
+const HighlightLanguageMappings = {
+	node: "typescript",
+	http: "bash"
+};
+const MarkdownContext = React$1.createContext({
+	highlight: (content) => content,
+	render: (content) => content
+});
+const useMarkdownContext = () => React$1.useContext(MarkdownContext);
+function useRenderMarkdown(content) {
+	const { render } = React$1.useContext(MarkdownContext);
+	return React$1.useMemo(() => content ? render(content) : void 0, [content, render]);
+}
+function useHighlight(content, language) {
+	const { highlight } = React$1.useContext(MarkdownContext);
+	const lang = language ?? useLanguage();
+	return React$1.useMemo(() => {
+		const rendered = highlight(content, HighlightLanguageMappings[lang] ?? lang);
+		return typeof rendered === "string" ? rendered : React$1.use(rendered);
+	}, [
+		content,
+		language,
+		highlight
+	]);
+}
+function MarkdownProvider({ render, highlight, children }) {
+	return /* @__PURE__ */ jsx(MarkdownContext.Provider, {
+		value: {
+			render,
+			highlight
+		},
+		children
+	});
+}
+
+//#endregion
+export { useRenderMarkdown as a, useMarkdownContext as i, MarkdownProvider as n, useHighlight as r, MarkdownContext as t };