@stainless-api/docs-ui 0.1.0-beta.29 → 0.1.0-beta.30

package/src/languages/java.tsx

@@ -1,358 +0,0 @@
-import * as React from 'react';
-import { JavaAST as AST } from '@stainless/sdk-json';
-
-import { useLanguage, useLanguageComponents } from '../contexts';
-import { useComponents } from '../contexts/use-components';
-import style from '../style';
-import { PropertyFn } from '.';
-
-function showFullType(type: AST.JavaType) {
-  return (
-    type.kind === 'JavaTypeReference' &&
-    (type.typeName === 'List' || (type.typeParameters && type.typeParameters.length > 0))
-  );
-}
-
-const constStyle: Record<string, string> = {
-  string: style.LiteralString,
-  number: style.LiteralNumeric,
-  boolean: style.LiteralBoolean,
-};
-
-type TypeProps = {
-  type: AST.JavaType;
-  optional?: boolean;
-};
-
-export function TypeName({ type, optional }: TypeProps) {
-  const Lang = useLanguageComponents();
-
-  if (type.kind === 'JavaTypeReference' && type.typeName === 'List') return 'List';
-
-  return <Lang.Type type={type} optional={optional} />;
-}
-
-export function Type({ type, optional }: TypeProps) {
-  const language = useLanguage();
-  const Lang = useLanguageComponents();
-  const { Join, SDKReference } = useComponents();
-
-  switch (type.kind) {
-    case 'JavaTypeReference': {
-      const name = type.typeName.split('.').at(-1);
-      const params = type.typeParameters?.map((param, key) => (
-        <Lang.Type key={key} type={param} optional={optional} />
-      ));
-
-      return (
-        <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
-          {params && params.length > 0 ? (
-            <>
-              <span className={style.TypeBracket}>{'<'}</span>
-              <Join items={params} limit={3}>
-                <span className={style.TextOperator}>, </span>
-              </Join>
-              <span className={style.TypeBracket}>{'>'}</span>
-            </>
-          ) : null}
-        </span>
-      );
-    }
-
-    case 'JavaTypeClass':
-    case 'JavaTypeUnion':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>class</span>
-        </span>
-      );
-
-    case 'JavaTypeEnum':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>{language === 'kotlin' ? 'enum class' : 'enum'}</span>
-        </span>
-      );
-
-    case 'JavaTypeVoid':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>{language === 'kotlin' ? 'Nothing?' : 'Void'}</span>
-        </span>
-      );
-
-    case 'JavaTypeBoolean':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>
-            {language === 'kotlin' || optional ? 'Boolean' : 'boolean'}
-          </span>
-        </span>
-      );
-
-    case 'JavaTypeDouble':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>{language === 'kotlin' || optional ? 'Double' : 'double'}</span>
-        </span>
-      );
-
-    case 'JavaTypeLong':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>{language === 'kotlin' || optional ? 'Long' : 'long'}</span>
-        </span>
-      );
-
-    case 'JavaTypeString':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeString}>String</span>
-        </span>
-      );
-
-    case 'JavaTypeConstant':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>JsonValue</span>;
-        </span>
-      );
-  }
-}
-
-export type MethodSignatureProps = {
-  decl: AST.JavaDeclFunction;
-};
-
-export function MethodSignature({ decl }: MethodSignatureProps) {
-  const Lang = useLanguageComponents();
-  const language = useLanguage();
-  const { Join, Tooltip } = useComponents();
-
-  const params = decl.parameters.map((param, i) => (
-    <React.Fragment key={i}>
-      <Tooltip content={<Lang.Type type={param.typeAnnotation} />}>
-        <span className={style.TextIdentifier}>{param.ident}</span>
-        {param.hasDefault && (
-          <>
-            {' '}
-            <span className={style.TextOperator}>=</span> <Lang.Type type={param.typeAnnotation} />
-            <span className={style.TextOperator}>.</span>
-            <span className={style.TextIdentifier}>none</span>
-            <span className={style.TextOperator}>()</span>
-          </>
-        )}
-      </Tooltip>
-    </React.Fragment>
-  ));
-
-  return (
-    <div className={style.MethodSignature}>
-      <span className={style.SignatureTitle}>
-        {decl.returnType && language !== 'kotlin' && (
-          <span className={style.SignatureReturns}>
-            <Lang.Type type={decl.returnType} />{' '}
-          </span>
-        )}
-        {decl.qualified && (
-          <span className={style.SignatureQualified}>
-            <span className={style.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
-          </span>
-        )}
-        <span className={style.SignatureName}>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-        </span>
-        <span className={style.MethodSignature}>
-          <span className={style.SignatureParen}>{'('}</span>
-
-          <span className={style.SignatureParams}>
-            <Join items={params}>
-              <span className={style.TextOperator}>{', '}</span>
-            </Join>
-          </span>
-
-          <span className={style.SignatureParen}>{')'} </span>
-          {decl.returnType && language === 'kotlin' && (
-            <>
-              <span className={style.TextOperator}>:</span> <Lang.Type type={decl.returnType} />
-            </>
-          )}
-        </span>
-      </span>
-    </div>
-  );
-}
-
-export type PropertyProps = {
-  decl: AST.JavaDeclaration;
-  children: PropertyFn;
-};
-
-export function Property({ decl, children }: PropertyProps) {
-  const Docs = useComponents();
-  const Lang = useLanguageComponents();
-  const language = useLanguage();
-
-  if (!decl) return null;
-
-  switch (decl.kind) {
-    case 'JavaDeclProperty': {
-      const typeRaw = <Lang.Type type={decl.type} optional={decl.optional} />;
-      const typeWrapped = decl.optional ? (
-        <>
-          <span className={style.TypeKeyword}>Optional</span>
-          <span className={style.TypeBracket}>{'<'}</span>
-          {typeRaw}
-          <span className={style.TypeBracket}>{'>'}</span>
-        </>
-      ) : (
-        typeRaw
-      );
-
-      const badges = (
-        <>
-          {decl.type.kind === 'JavaTypeConstant' && (
-            <Docs.Tooltip content={<span className={style.TextIdentifier}>{decl.type.value}</span>}>
-              <span className={style.TextIdentifier}>constant</span>
-            </Docs.Tooltip>
-          )}
-        </>
-      );
-
-      return children({
-        name: decl.ident,
-        typeName: <Lang.TypeName type={decl.type} optional={decl.optional} />,
-        type: showFullType(decl.type) && typeWrapped,
-        badges,
-      });
-    }
-
-    case 'JavaDeclConst':
-      return children({
-        name: decl.ident,
-        typeName: 'const',
-        type: <span className={constStyle[typeof decl.value]}>{JSON.stringify(decl.value)}</span>,
-      });
-
-    case 'JavaDeclType': {
-      const typeName =
-        decl.type.kind === 'JavaTypeUnion'
-          ? 'union'
-          : decl.type.kind === 'JavaTypeEnum'
-            ? language === 'kotlin'
-              ? 'enum class'
-              : 'enum'
-            : 'class';
-
-      return children({ name: decl.ident, typeName });
-    }
-
-    case 'JavaDeclReference':
-      return children({ type: <Lang.Type type={decl.type} /> });
-  }
-}
-
-export type DeclarationProps = {
-  decl: AST.JavaDeclaration;
-};
-
-export function Declaration({ decl }: DeclarationProps) {
-  const Docs = useComponents();
-  const Lang = useLanguageComponents();
-  const language = useLanguage();
-
-  if (!decl) return null;
-
-  switch (decl.kind) {
-    case 'JavaDeclConst':
-      return (
-        <>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-          <span className={style.TextPunctuation}>{'('}</span>
-          {JSON.stringify(decl.value)}
-          <span className={style.TextPunctuation}>{')'}</span>
-        </>
-      );
-
-    case 'JavaDeclType': {
-      const keyword =
-        decl.type.kind === 'JavaTypeEnum' ? (language === 'kotlin' ? 'enum class' : 'enum') : 'class';
-
-      return (
-        <>
-          <span className={style.TextKeyword}>{keyword}</span>{' '}
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-          <span className={style.TextPunctuation}>:</span>
-          {decl.type.kind === 'JavaTypeUnion' && (
-            <>
-              {' '}
-              <Docs.Tooltip content="A class that can be one of several variants.">
-                <Docs.Badge id="java-union">union</Docs.Badge>
-              </Docs.Tooltip>{' '}
-            </>
-          )}
-        </>
-      );
-    }
-
-    case 'JavaDeclProperty': {
-      const inlineType = <Lang.Type type={decl.type} optional={decl.optional} />;
-
-      const ident = (
-        <span className={style.TypePropertyName}>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-        </span>
-      );
-
-      const suffix =
-        decl.type.kind === 'JavaTypeConstant' ? (
-          <>
-            {' '}
-            <Docs.Tooltip content={<span className={style.TextIdentifier}>{decl.type.value}</span>}>
-              <Docs.Badge id="java-constant">constant</Docs.Badge>
-            </Docs.Tooltip>
-          </>
-        ) : null;
-
-      if (language === 'kotlin')
-        return (
-          <>
-            {ident}
-            <span className={style.TextPunctuation}>:</span>{' '}
-            {decl.optional ? (
-              <>
-                <span className={style.TypeReference}>Optional</span>
-                <span className={style.TypeBracket}>{'<'}</span>
-                {inlineType}
-                <span className={style.TypeBracket}>{'>'}</span>
-              </>
-            ) : (
-              inlineType
-            )}
-            {suffix}
-          </>
-        );
-
-      return (
-        <>
-          {decl.optional ? (
-            <>
-              <span className={style.TypeReference}>Optional</span>
-              <span className={style.TypeBracket}>{'<'}</span>
-              {inlineType}
-              <span className={style.TypeBracket}>{'>'}</span>
-            </>
-          ) : (
-            inlineType
-          )}{' '}
-          {ident}
-          {suffix}
-        </>
-      );
-    }
-
-    case 'JavaDeclReference':
-      return <Lang.Type type={decl.type} />;
-  }
-}

package/src/languages/python.tsx

@@ -1,258 +0,0 @@
-import * as React from 'react';
-import { PythonAST as AST } from '@stainless/sdk-json';
-import { useLanguageComponents } from '../contexts';
-import { useComponents } from '../contexts/use-components';
-import style from '../style';
-import { PropertyFn } from '.';
-
-const constStyle: Record<string, string> = {
-  string: style.LiteralString,
-  number: style.LiteralNumeric,
-  boolean: style.LiteralBoolean,
-};
-
-function showFullType(type: AST.PythonType): boolean {
-  if (type.kind !== 'PythonTypeReference') return false;
-  return type.typeName === 'Optional'
-    ? showFullType(type.typeParameters![0]!)
-    : type.typeParameters!.length > 0;
-}
-
-type TypeProps = {
-  type: AST.PythonType;
-};
-
-export function TypeName({ type }: TypeProps) {
-  const Lang = useLanguageComponents();
-
-  if (type.kind === 'PythonTypeReference') {
-    switch (type.typeName) {
-      case 'Optional':
-        return <Lang.TypeName type={type.typeParameters![0]!} />;
-      case 'List':
-      case 'Iterable':
-      case 'Literal':
-      case 'Union':
-        return type.typeName.toLowerCase();
-    }
-  }
-
-  return <Lang.Type type={type} />;
-}
-
-export function Type({ type }: TypeProps) {
-  const Lang = useLanguageComponents();
-  const { Join, SDKReference } = useComponents();
-
-  switch (type.kind) {
-    case 'PythonTypeAny':
-    case 'PythonTypeUnknown':
-    case 'PythonTypeInt':
-    case 'PythonTypeFloat':
-    case 'PythonTypeBool':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>{type.kind.slice(10).toLowerCase()}</span>
-        </span>
-      );
-
-    case 'PythonTypeString':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeString}>str</span>
-        </span>
-      );
-
-    case 'PythonTypeLiteral':
-      return (
-        <span className={style.Type}>
-          <span className={constStyle[typeof type.literal.value]!}>{JSON.stringify(type.literal.value)}</span>
-        </span>
-      );
-
-    case 'PythonTypeArray':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeArray}>{'Array<'}</span>
-          <Lang.Type type={type.elementType} />
-          <span className={style.TypeArray}>{'>'}</span>
-        </span>
-      );
-
-    case 'PythonTypeClass':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>class</span>
-        </span>
-      );
-
-    case 'PythonTypeMap':
-      return (
-        <span className={style.Type}>
-          <span className={style.TypeKeyword}>Dict</span>
-        </span>
-      );
-
-    case 'PythonTypeReference': {
-      const params = type.typeParameters?.map((param, key) => <Lang.Type key={key} type={param} />);
-
-      return (
-        <span className={style.Type}>
-          <span className={type.typeName === 'Optional' ? style.TypeArray : ''}>
-            <SDKReference stainlessPath={type.$ref!}>{type.typeName}</SDKReference>
-          </span>
-          {params && params.length > 0 && (
-            <>
-              <span className={style.TypeBracket}>{'['}</span>
-              <Join items={params} limit={3}>
-                <span className={style.TextOperator}>, </span>
-              </Join>
-              <span className={style.TypeBracket}>{']'}</span>
-            </>
-          )}
-        </span>
-      );
-    }
-  }
-}
-
-export type MethodSignatureProps = {
-  decl: AST.PythonDeclFunction;
-};
-
-export function MethodSignature({ decl }: MethodSignatureProps) {
-  const Lang = useLanguageComponents();
-  const { Join, Tooltip } = useComponents();
-
-  const params = decl.parameters.map((param, i) => (
-    <React.Fragment key={i}>
-      <Tooltip content={<Lang.Type type={param.type} />}>
-        <span className={style.TextIdentifier}>{param.ident}</span>
-      </Tooltip>
-    </React.Fragment>
-  ));
-
-  return (
-    <div className={style.MethodSignature}>
-      <span className={style.SignatureTitle}>
-        {decl.async && <span className={style.TextKeyword}>async </span>}
-        {decl.qualified && (
-          <span className={style.SignatureQualified}>
-            <span className={style.TextIdentifier}>{decl.qualified?.slice(0, -decl.ident.length)}</span>
-          </span>
-        )}
-        <span className={style.SignatureName}>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-        </span>
-        <span className={style.MethodSignature}>
-          <span className={style.SignatureParen}>{'('}</span>
-
-          <span className={style.SignatureParams}>
-            <Join items={params}>
-              <span className={style.TextOperator}>{', '}</span>
-            </Join>
-          </span>
-
-          <span className={style.SignatureParen}>{')'} </span>
-          {decl.returns && (
-            <>
-              <span className={style.TextOperator}>{' -> '}</span>
-              <Lang.Type type={decl.returns} />
-            </>
-          )}
-        </span>
-      </span>
-    </div>
-  );
-}
-
-export type PropertyProps = {
-  decl: AST.PythonDeclaration;
-  children: PropertyFn;
-};
-
-export function Property({ decl, children }: PropertyProps) {
-  const Lang = useLanguageComponents();
-
-  if (!decl) return;
-
-  switch (decl.kind) {
-    case 'PythonDeclProperty':
-      return children({
-        name: decl.ident,
-        typeName: <Lang.TypeName type={decl.type} />,
-        type: showFullType(decl.type) && <Lang.Type type={decl.type} />,
-      });
-
-    case 'PythonDeclClass':
-      return children({ name: decl.ident, typeName: 'class' });
-
-    case 'PythonDeclType':
-      return children({
-        name: decl.ident,
-        typeName: 'type',
-        type: <Lang.Type type={decl.type} />,
-      });
-
-    case 'PythonDeclReference':
-      return children({ type: <Lang.Type type={decl.type} /> });
-  }
-}
-
-export type DeclarationProps = { decl: AST.PythonDeclaration };
-
-export function Declaration({ decl }: DeclarationProps) {
-  const Lang = useLanguageComponents();
-
-  if (!decl) return;
-
-  switch (decl.kind) {
-    case 'PythonDeclProperty': {
-      const nullable =
-        decl.type.kind === 'PythonTypeReference' &&
-        decl.type.typeName === 'Optional' &&
-        (decl.type.typeParameters ?? []).length > 0;
-
-      return (
-        <>
-          <span className={style.TypePropertyName}>
-            <span className={style.TextIdentifier}>{decl.ident}</span>
-          </span>
-          <span className={style.TextPunctuation}>: </span>
-          {decl.optional && !nullable ? (
-            <>
-              <span className={style.TypePlain}>Optional</span>
-              <span className={style.TypeBracket}>{'['}</span>
-              <Lang.Type type={decl.type} />
-              <span className={style.TypeBrace}>{']'}</span>
-            </>
-          ) : (
-            <Lang.Type type={decl.type} />
-          )}
-        </>
-      );
-    }
-
-    case 'PythonDeclClass':
-      return (
-        <>
-          <span className={style.TextKeyword}>class </span>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-          <span className={style.TextPunctuation}>: </span>
-          <span className={`${style.TypePreviewContent} ${style.TextPunctuation}`}>…</span>
-        </>
-      );
-
-    case 'PythonDeclType':
-      return (
-        <>
-          <span className={style.TextIdentifier}>{decl.ident}</span>
-          <span className={style.TextOperator}> = </span>
-          <Lang.Type type={decl.type} />
-        </>
-      );
-
-    case 'PythonDeclReference':
-      return <Lang.Type type={decl.type} />;
-  }
-}