@cparra/apexdocs 2.25.0-alpha.3 → 2.25.0-alpha.5

package/src/core/markdown/adapters/renderable-to-page-data.ts

@@ -0,0 +1,92 @@
+import { ReferenceGuideReference, Renderable, RenderableBundle, RenderableEnum } from './types';
+import { DocPageData, DocumentationBundle } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+import { CompilationRequest, Template } from '../templates/template';
+import { enumMarkdownTemplate } from '../templates/enum-template';
+import { interfaceMarkdownTemplate } from '../templates/interface-template';
+import { classMarkdownTemplate } from '../templates/class-template';
+
+export const convertToDocumentationBundle = (
+  referenceGuideTemplate: string,
+  { references, renderables }: RenderableBundle,
+): DocumentationBundle => ({
+  referenceGuide: {
+    directory: '',
+    frontmatter: null,
+    content: referencesToReferenceGuideContent(references, referenceGuideTemplate),
+    fileExtension: 'md',
+    fileName: 'index',
+  },
+  docs: renderables.map((renderable: Renderable) => renderableToPageData(Object.values(references).flat(), renderable)),
+});
+
+function referencesToReferenceGuideContent(
+  references: { [key: string]: ReferenceGuideReference[] },
+  template: string,
+): string {
+  function alphabetizeReferences(references: { [key: string]: ReferenceGuideReference[] }): {
+    [key: string]: ReferenceGuideReference[];
+  } {
+    return Object.keys(references)
+      .sort((a, b) => a.localeCompare(b))
+      .reduce<{ [key: string]: ReferenceGuideReference[] }>((acc, key) => {
+        acc[key] = references[key].sort((a, b) => a.title.toString().localeCompare(b.title.toString()));
+        return acc;
+      }, {});
+  }
+
+  return pipe(references, alphabetizeReferences, (references) =>
+    compile({
+      template: template,
+      source: references,
+    }),
+  );
+}
+
+function renderableToPageData(referenceGuideReference: ReferenceGuideReference[], renderable: Renderable): DocPageData {
+  function buildDocOutput(renderable: Renderable, docContents: string): DocPageData {
+    const reference = referenceGuideReference.find(
+      (ref) => ref.typeName.toLowerCase() === renderable.name.toLowerCase(),
+    );
+
+    const namespacePrefix = renderable.namespace ? `${renderable.namespace}.` : '';
+
+    return {
+      source: {
+        filePath: renderable.filePath,
+        name: renderable.name,
+        type: renderable.type,
+      },
+      fileName: `${namespacePrefix}${renderable.name}`,
+      fileExtension: 'md',
+      directory: `${reference?.directory}`,
+      frontmatter: null,
+      content: docContents,
+      group: renderable.doc.group ?? 'Miscellaneous',
+    };
+  }
+
+  return pipe(renderable, resolveApexTypeTemplate, compile, (docContents) => buildDocOutput(renderable, docContents));
+}
+
+function resolveApexTypeTemplate(renderable: Renderable): CompilationRequest {
+  function getTemplate(renderable: Renderable): string {
+    switch (renderable.type) {
+      case 'enum':
+        return enumMarkdownTemplate;
+      case 'interface':
+        return interfaceMarkdownTemplate;
+      case 'class':
+        return classMarkdownTemplate;
+    }
+  }
+
+  return {
+    template: getTemplate(renderable),
+    source: renderable as RenderableEnum,
+  };
+}
+
+function compile(request: CompilationRequest): string {
+  return Template.getInstance().compile(request);
+}

package/src/core/{adapters → markdown/adapters}/type-utils.ts

@@ -1,4 +1,4 @@
-import { CodeBlock, EmptyLine, RenderableContent } from './types';
+import { CodeBlock, EmptyLine, InlineCode, RenderableContent } from './types';
 
 export function isEmptyLine(content: RenderableContent): content is EmptyLine {
   return Object.keys(content).includes('__type') && (content as { __type: string }).__type === 'empty-line';
@@ -7,3 +7,7 @@ export function isEmptyLine(content: RenderableContent): content is EmptyLine {
 export function isCodeBlock(content: RenderableContent): content is CodeBlock {
   return Object.keys(content).includes('__type') && (content as { __type: string }).__type === 'code-block';
 }
+
+export function isInlineCode(content: RenderableContent): content is InlineCode {
+  return Object.keys(content).includes('__type') && (content as { __type: string }).__type === 'inline-code';
+}

package/src/core/{adapters → markdown/adapters}/types.d.ts

@@ -20,10 +20,24 @@ export type ClassMirrorWithInheritanceChain = ClassMirror & { inheritanceChain:
 export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
 export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
 export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
-export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;
 
 // Renderable types
 
+export type ReferenceGuideReference = {
+  typeName: string;
+  directory: string;
+  title: Link;
+  description: RenderableContent[] | undefined;
+};
+
+export type RenderableBundle = {
+  // References are grouped by their defined @group annotation
+  references: {
+    [key: string]: ReferenceGuideReference[];
+  };
+  renderables: Renderable[];
+};
+
 export type Link = {
   readonly __type: 'link';
   title: string;
@@ -36,7 +50,9 @@ export type EmptyLine = {
 
 export type StringOrLink = string | Link;
 
-export type RenderableContent = StringOrLink | EmptyLine | CodeBlock;
+export type GetRenderableContentByTypeName = (typeName: string) => StringOrLink;
+
+export type RenderableContent = StringOrLink | EmptyLine | CodeBlock | InlineCode;
 
 type EnumValue = {
   value: string;
@@ -59,6 +75,11 @@ type CodeBlock = {
   content: string[];
 };
 
+type InlineCode = {
+  readonly __type: 'inline-code';
+  content: string;
+};
+
 type RenderableDocumentation = {
   annotations?: Annotation[];
   description?: RenderableContent[];
@@ -159,4 +180,4 @@ export type RenderableEnum = RenderableType & {
   values: RenderableSection<EnumValue[]>;
 };
 
-export type Renderable = RenderableClass | RenderableInterface | RenderableEnum;
+export type Renderable = (RenderableClass | RenderableInterface | RenderableEnum) & { filePath: string };

package/src/core/markdown/generate-docs.ts

@@ -0,0 +1,158 @@
+import { pipe } from 'fp-ts/function';
+import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+import yaml from 'js-yaml';
+
+import { apply } from '#utils/fp';
+import {
+  DocPageData,
+  DocumentationBundle,
+  Frontmatter,
+  PostHookDocumentationBundle,
+  ReferenceGuidePageData,
+  SourceFile,
+  TransformDocPage,
+  TransformDocs,
+  TransformReferenceGuide,
+  UserDefinedMarkdownConfig,
+} from '../shared/types';
+import { parsedFilesToRenderableBundle } from './adapters/renderable-bundle';
+import { reflectSourceCode } from './reflection/reflect-source';
+import { checkForReflectionErrors } from './reflection/error-handling';
+import { addInheritanceChainToTypes } from './reflection/inheritance-chain-expanion';
+import { addInheritedMembersToTypes } from './reflection/inherited-member-expansion';
+import { convertToDocumentationBundle } from './adapters/renderable-to-page-data';
+import { filterScope } from './reflection/filter-scope';
+import { Template } from './templates/template';
+import { hookableTemplate } from './templates/hookable';
+import { sortMembers } from './reflection/sort-members';
+import { isSkip } from '../shared/utils';
+
+export type MarkdownGeneratorConfig = Pick<
+  UserDefinedMarkdownConfig,
+  | 'targetDir'
+  | 'scope'
+  | 'namespace'
+  | 'defaultGroupName'
+  | 'transformReferenceGuide'
+  | 'transformDocs'
+  | 'transformDocPage'
+> & {
+  referenceGuideTemplate: string;
+  sortMembersAlphabetically: boolean;
+};
+
+export class HookError {
+  readonly _tag = 'HookError';
+
+  constructor(public error: unknown) {}
+}
+
+export function generateDocs(apexBundles: SourceFile[], config: MarkdownGeneratorConfig) {
+  const filterOutOfScope = apply(filterScope, config.scope);
+  const convertToRenderableBundle = apply(parsedFilesToRenderableBundle, config);
+  const convertToDocumentationBundleForTemplate = apply(convertToDocumentationBundle, config.referenceGuideTemplate);
+  const sortTypeMembers = apply(sortMembers, config.sortMembersAlphabetically);
+
+  return pipe(
+    apexBundles,
+    reflectSourceCode,
+    checkForReflectionErrors,
+    E.map(filterOutOfScope),
+    E.map(addInheritedMembersToTypes),
+    E.map(addInheritanceChainToTypes),
+    E.map(sortTypeMembers),
+    E.map(convertToRenderableBundle),
+    E.map(convertToDocumentationBundleForTemplate),
+    TE.fromEither,
+    TE.flatMap((bundle) =>
+      TE.tryCatch(
+        () => documentationBundleHook(bundle, config),
+        (error) => new HookError(error),
+      ),
+    ),
+    TE.map((bundle: PostHookDocumentationBundle) => ({
+      referenceGuide: isSkip(bundle.referenceGuide)
+        ? bundle.referenceGuide
+        : {
+            ...bundle.referenceGuide,
+            content: Template.getInstance().compile({
+              source: {
+                frontmatter: toFrontmatterString(bundle.referenceGuide.frontmatter),
+                content: bundle.referenceGuide.content,
+              },
+              template: hookableTemplate,
+            }),
+          },
+      docs: bundle.docs.map((doc) => ({
+        ...doc,
+        content: Template.getInstance().compile({
+          source: {
+            frontmatter: toFrontmatterString(doc.frontmatter),
+            content: doc.content,
+          },
+          template: hookableTemplate,
+        }),
+      })),
+    })),
+  );
+}
+
+function toFrontmatterString(frontmatter: Frontmatter): string {
+  if (typeof frontmatter === 'string') {
+    return frontmatter;
+  }
+
+  if (!frontmatter) {
+    return '';
+  }
+
+  const yamlString = yaml.dump(frontmatter);
+  return `---\n${yamlString}---\n`;
+}
+
+// Configurable hooks
+function passThroughHook<T>(value: T): T {
+  return value;
+}
+
+const documentationBundleHook = async (
+  bundle: DocumentationBundle,
+  config: MarkdownGeneratorConfig,
+): Promise<PostHookDocumentationBundle> => {
+  return {
+    referenceGuide: await transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
+    docs: await transformDocs(bundle.docs, config.transformDocs, config.transformDocPage),
+  };
+};
+
+const transformReferenceGuide = async (
+  referenceGuide: ReferenceGuidePageData,
+  hook: TransformReferenceGuide = passThroughHook,
+) => {
+  const result = await hook(referenceGuide);
+  if (isSkip(result)) {
+    return result;
+  }
+
+  return {
+    ...referenceGuide,
+    ...(await hook(referenceGuide)),
+  };
+};
+
+const transformDocs = async (
+  docs: DocPageData[],
+  transformDocsHook: TransformDocs = passThroughHook,
+  transformDocPageHook: TransformDocPage = passThroughHook,
+): Promise<Awaited<DocPageData[]>> => {
+  const transformed = await transformDocsHook(docs);
+  return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
+};
+
+const transformDocPage = async (doc: DocPageData, hook: TransformDocPage = passThroughHook) => {
+  return {
+    ...doc,
+    ...(await hook(doc)),
+  };
+};

package/src/core/markdown/reflection/error-handling.ts

@@ -0,0 +1,37 @@
+import * as E from 'fp-ts/Either';
+import { ParsedFile } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+
+export class ReflectionErrors {
+  readonly _tag = 'ReflectionErrors';
+  constructor(public errors: ReflectionError[]) {}
+}
+
+export class ReflectionError {
+  constructor(
+    public file: string,
+    public message: string,
+  ) {}
+}
+
+export function checkForReflectionErrors(reflectionResult: E.Either<ReflectionError, ParsedFile>[]) {
+  function reduceReflectionResultIntoSingleEither(results: E.Either<ReflectionError, ParsedFile>[]): {
+    errors: ReflectionError[];
+    parsedFiles: ParsedFile[];
+  } {
+    return results.reduce<{ errors: ReflectionError[]; parsedFiles: ParsedFile[] }>(
+      (acc, result) => {
+        E.isLeft(result) ? acc.errors.push(result.left) : acc.parsedFiles.push(result.right);
+        return acc;
+      },
+      {
+        errors: [],
+        parsedFiles: [],
+      },
+    );
+  }
+
+  return pipe(reflectionResult, reduceReflectionResultIntoSingleEither, ({ errors, parsedFiles }) =>
+    errors.length ? E.left(new ReflectionErrors(errors)) : E.right(parsedFiles),
+  );
+}

package/src/core/markdown/reflection/filter-scope.ts

@@ -0,0 +1,13 @@
+import { ParsedFile } from '../../shared/types';
+import Manifest from '../../manifest';
+
+export function filterScope(scopes: string[], parsedFiles: ParsedFile[]): ParsedFile[] {
+  return parsedFiles
+    .filter(({ type }) => Manifest.shouldFilterType(type, scopes))
+    .map((parsedFile) => {
+      return {
+        ...parsedFile,
+        type: Manifest.filterSingleType(parsedFile.type, scopes, false),
+      };
+    });
+}

package/src/core/markdown/reflection/inheritance-chain-expanion.ts

@@ -0,0 +1,22 @@
+import { ClassMirror, Type } from '@cparra/apex-reflection';
+import { createInheritanceChain } from './inheritance-chain';
+import { ParsedFile } from '../../shared/types';
+import { parsedFilesToTypes } from '../utils';
+
+export const addInheritanceChainToTypes = (parsedFiles: ParsedFile[]) =>
+  parsedFiles.map((parsedFile) => ({
+    ...parsedFile,
+    type: addInheritanceChain(parsedFile.type, parsedFilesToTypes(parsedFiles)),
+  }));
+
+function addInheritanceChain<T extends Type>(current: T, repository: Type[]): T {
+  if (current.type_name === 'enum' || current.type_name === 'interface') {
+    return current;
+  } else {
+    const inheritanceChain = createInheritanceChain(repository, current as ClassMirror);
+    return {
+      ...current,
+      inheritanceChain,
+    };
+  }
+}

package/src/core/markdown/reflection/inherited-member-expansion.ts

@@ -0,0 +1,105 @@
+import { ClassMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
+import { ParsedFile } from '../../shared/types';
+import { pipe } from 'fp-ts/function';
+import { parsedFilesToTypes } from '../utils';
+
+export const addInheritedMembersToTypes = (parsedFiles: ParsedFile[]) =>
+  parsedFiles.map((parsedFile) => addInheritedMembers(parsedFilesToTypes(parsedFiles), parsedFile));
+
+export function addInheritedMembers(repository: Type[], parsedFile: ParsedFile): ParsedFile {
+  function addInheritedMembersToType<T extends Type>(repository: Type[], current: T): T {
+    if (current.type_name === 'enum') {
+      return current;
+    } else if (current.type_name === 'interface') {
+      return addInheritedInterfaceMethods(current as InterfaceMirror, repository) as T;
+    } else {
+      return addInheritedClassMembers(current as ClassMirror, repository) as T;
+    }
+  }
+
+  return {
+    ...parsedFile,
+    type: addInheritedMembersToType(repository, parsedFile.type),
+  };
+}
+
+function addInheritedInterfaceMethods(interfaceMirror: InterfaceMirror, repository: Type[]): InterfaceMirror {
+  function methodAlreadyExists(memberName: string, members: { name: string }[]) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+
+  function parentExtractor(interfaceMirror: InterfaceMirror): string[] {
+    return interfaceMirror.extended_interfaces;
+  }
+
+  const parents = getParents(parentExtractor, interfaceMirror, repository);
+  return {
+    ...interfaceMirror,
+    methods: parents.reduce(
+      (acc, currentValue) => [
+        ...acc,
+        ...currentValue.methods
+          .filter((method) => !methodAlreadyExists(method.name, acc))
+          .map((method) => ({
+            ...method,
+            inherited: true,
+          })),
+      ],
+      interfaceMirror.methods,
+    ),
+  };
+}
+
+function addInheritedClassMembers(classMirror: ClassMirror, repository: Type[]): ClassMirror {
+  function memberAlreadyExists(memberName: string, members: { name: string }[]) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+
+  function parentExtractor(classMirror: ClassMirror): string[] {
+    return classMirror.extended_class ? [classMirror.extended_class] : [];
+  }
+
+  function filterMember<T extends { name: string; access_modifier: string }>(members: T[], existing: T[]): T[] {
+    return members
+      .filter((member) => member.access_modifier.toLowerCase() !== 'private')
+      .filter((member) => !memberAlreadyExists(member.name, existing))
+      .map((member) => ({
+        ...member,
+        inherited: true,
+      }));
+  }
+
+  const parents = getParents(parentExtractor, classMirror, repository);
+  return {
+    ...classMirror,
+    fields: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.fields, acc)],
+      classMirror.fields,
+    ),
+    properties: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.properties, acc)],
+      classMirror.properties,
+    ),
+    methods: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.methods, acc)],
+      classMirror.methods,
+    ),
+  };
+}
+
+function getParents<T extends Type>(
+  extendedNamesExtractor: (current: T) => string[],
+  current: T,
+  repository: Type[],
+): T[] {
+  return pipe(
+    extendedNamesExtractor(current),
+    (interfaces: string[]) => interfaces.map((interfaceName) => repository.find((type) => type.name === interfaceName)),
+    (interfaces = []) => interfaces.filter((type) => type !== undefined) as T[],
+    (interfaces) =>
+      interfaces.reduce<T[]>(
+        (acc, current) => [...acc, ...getParents(extendedNamesExtractor, current, repository)],
+        interfaces,
+      ),
+  );
+}

package/src/core/markdown/reflection/reflect-source.ts

@@ -0,0 +1,41 @@
+import { ParsedFile, SourceFile } from '../../shared/types';
+import * as E from 'fp-ts/Either';
+import { reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
+import { pipe } from 'fp-ts/function';
+import * as O from 'fp-ts/Option';
+import { parseApexMetadata } from '../../parse-apex-metadata';
+import { ReflectionError } from './error-handling';
+
+export function reflectSourceCode(apexBundles: SourceFile[]) {
+  return apexBundles.map(reflectSourceBody);
+}
+
+function reflectSourceBody(apexBundle: SourceFile): E.Either<ReflectionError, ParsedFile> {
+  const { filePath, content: input, metadataContent: metadata } = apexBundle;
+  const result = mirrorReflection(input);
+  return result.error
+    ? E.left(new ReflectionError(filePath, result.error.message))
+    : E.right({
+        filePath,
+        type: addFileMetadataToTypeAnnotation(result.typeMirror!, metadata),
+      });
+}
+
+function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
+  return pipe(
+    O.fromNullable(metadata),
+    O.map((metadata) => {
+      const metadataParams = parseApexMetadata(metadata);
+      metadataParams.forEach((value, key) => {
+        const declaration = `${key}: ${value}`;
+        type.annotations.push({
+          rawDeclaration: declaration,
+          name: declaration,
+          type: declaration,
+        });
+      });
+      return type;
+    }),
+    O.getOrElse(() => type),
+  );
+}

package/src/core/markdown/reflection/sort-members.ts

@@ -0,0 +1,59 @@
+import { ClassMirror, EnumMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
+import { ParsedFile } from '../../shared/types';
+
+type Named = { name: string };
+
+export function sortMembers(shouldSortMembers: boolean, parsedFiles: ParsedFile[]): ParsedFile[] {
+  return parsedFiles.map((parsedFile) => ({
+    ...parsedFile,
+    type: sortTypeMember(parsedFile.type, shouldSortMembers),
+  }));
+}
+
+function sortByNames<T extends Named>(shouldSort: boolean, a: T, b: T): number {
+  if (shouldSort) {
+    return a.name.localeCompare(b.name);
+  }
+  return 0;
+}
+
+function sortNamed<T extends Named>(shouldSort: boolean, items: T[]): T[] {
+  return items.sort((a, b) => sortByNames(shouldSort, a, b));
+}
+
+function sortTypeMember(type: Type, shouldSort: boolean): Type {
+  switch (type.type_name) {
+    case 'enum':
+      return sortEnumValues(shouldSort, type as EnumMirror);
+    case 'interface':
+      return sortInterfaceMethods(shouldSort, type as InterfaceMirror);
+    case 'class':
+      return sortClassMembers(shouldSort, type as ClassMirror);
+  }
+}
+
+function sortEnumValues(shouldSort: boolean, enumType: EnumMirror): EnumMirror {
+  return {
+    ...enumType,
+    values: sortNamed(shouldSort, enumType.values),
+  };
+}
+
+function sortInterfaceMethods(shouldSort: boolean, interfaceType: InterfaceMirror): InterfaceMirror {
+  return {
+    ...interfaceType,
+    methods: sortNamed(shouldSort, interfaceType.methods),
+  };
+}
+
+function sortClassMembers(shouldSort: boolean, classType: ClassMirror): ClassMirror {
+  return {
+    ...classType,
+    fields: sortNamed(shouldSort, classType.fields),
+    classes: sortNamed(shouldSort, classType.classes),
+    enums: sortNamed(shouldSort, classType.enums),
+    interfaces: sortNamed(shouldSort, classType.interfaces),
+    methods: sortNamed(shouldSort, classType.methods),
+    properties: sortNamed(shouldSort, classType.properties),
+  };
+}

package/src/{transpiler/markdown/plain-markdown → core/markdown/templates}/class-template.ts

@@ -8,11 +8,13 @@ export const classMarkdownTemplate = `
 
 {{#if extends.length}}
 **Inheritance**
+
 {{#each extends}}{{link this}}{{#unless @last}} < {{/unless}}{{/each}}
 {{/if}}
 
 {{#if implements}}
 **Implements**
+
 {{#each implements}}
 {{link this}}{{#unless @last}}, {{/unless}}
 {{/each}}

package/src/{transpiler/markdown/plain-markdown → core/markdown/templates}/constructors-partial-template.ts

@@ -13,7 +13,7 @@ export const constructorsPartialTemplate = `
 | Name | Type | Description |
 |------|------|-------------|
 {{#each parameters.value}}
-| {{name}} | {{type}} | {{description}} |
+| {{name}} | {{link type}} | {{description}} |
 {{/each}}
 {{/if}}
 

package/src/core/markdown/templates/hookable.ts

@@ -0,0 +1,7 @@
+export const hookableTemplate = `
+{{#if frontmatter}}
+{{{frontmatter}}}
+{{/if}}
+
+{{{content}}}
+`.trim();

package/src/core/{template.ts → markdown/templates/template.ts}

@@ -1,15 +1,15 @@
 import Handlebars from 'handlebars';
-import { typeDocPartial } from '../transpiler/markdown/plain-markdown/type-doc-partial';
-import { documentablePartialTemplate } from '../transpiler/markdown/plain-markdown/documentable-partial-template';
-import { methodsPartialTemplate } from '../transpiler/markdown/plain-markdown/methods-partial-template';
-import { constructorsPartialTemplate } from '../transpiler/markdown/plain-markdown/constructors-partial-template';
-import { fieldsPartialTemplate } from '../transpiler/markdown/plain-markdown/fieldsPartialTemplate';
-import { classMarkdownTemplate } from '../transpiler/markdown/plain-markdown/class-template';
-import { enumMarkdownTemplate } from '../transpiler/markdown/plain-markdown/enum-template';
-import { interfaceMarkdownTemplate } from '../transpiler/markdown/plain-markdown/interface-template';
-import { CodeBlock, RenderableContent, StringOrLink } from './adapters/types';
-import { isCodeBlock, isEmptyLine } from './adapters/type-utils';
-import { groupedMembersPartialTemplate } from '../transpiler/markdown/plain-markdown/grouped-members-partial-template';
+import { CodeBlock, RenderableContent, StringOrLink } from '../adapters/types';
+import { isCodeBlock, isEmptyLine, isInlineCode } from '../adapters/type-utils';
+import { typeDocPartial } from './type-doc-partial';
+import { documentablePartialTemplate } from './documentable-partial-template';
+import { methodsPartialTemplate } from './methods-partial-template';
+import { groupedMembersPartialTemplate } from './grouped-members-partial-template';
+import { constructorsPartialTemplate } from './constructors-partial-template';
+import { fieldsPartialTemplate } from './fieldsPartialTemplate';
+import { classMarkdownTemplate } from './class-template';
+import { enumMarkdownTemplate } from './enum-template';
+import { interfaceMarkdownTemplate } from './interface-template';
 
 export type CompilationRequest = {
   template: string;
@@ -90,10 +90,13 @@ const resolveRenderableContent = (description?: RenderableContent[]): string =>
 
   function reduceDescription(acc: string, curr: RenderableContent) {
     if (isEmptyLine(curr)) {
-      return acc + '\n\n';
+      return acc + '\n';
     }
     if (isCodeBlock(curr)) {
       return acc + convertCodeBlock(curr) + '\n';
+    }
+    if (isInlineCode(curr)) {
+      return acc + inlineCode(curr.content).toString() + ' ';
     } else {
       return acc + Handlebars.escapeExpression(link(curr)).trim() + ' ';
     }

package/src/core/markdown/utils.ts

@@ -0,0 +1,3 @@
+import { ParsedFile } from '../shared/types';
+
+export const parsedFilesToTypes = (parsedFiles: ParsedFile[]) => parsedFiles.map((parsedFile) => parsedFile.type);