@cparra/apexdocs 2.25.0-alpha.0 → 2.25.0-alpha.10

package/src/adapters/__tests__/interface-adapter.spec.ts

@@ -1,76 +0,0 @@
-import { InterfaceMirrorBuilder } from '../../test-helpers/InterfaceMirrorBuilder';
-import { AnnotationBuilder } from '../../test-helpers/AnnotationBuilder';
-import { MethodMirrorBuilder, ParameterBuilder } from '../../test-helpers/MethodMirrorBuilder';
-import { interfaceTypeToInterfaceSource } from '../apex-types';
-
-describe('Conversion from InterfaceMirror to InterfaceSource understandable by the templating engine', () => {
-  it('converts the name', () => {
-    const interfaceMirror = new InterfaceMirrorBuilder().withName('SampleInterface').build();
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror);
-
-    expect(interfaceSource.name).toBe('SampleInterface');
-  });
-
-  it('converts the access modifier', () => {
-    const interfaceMirror = new InterfaceMirrorBuilder().build();
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror);
-
-    expect(interfaceSource.accessModifier).toBe('public');
-  });
-
-  it('converts annotations', () => {
-    const interfaceMirror = new InterfaceMirrorBuilder()
-      .addAnnotation(new AnnotationBuilder().withName('MyAnnotation').build())
-      .build();
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror);
-
-    expect(interfaceSource.annotations).toEqual(['MYANNOTATION']);
-  });
-
-  it('converts method declarations. Method with no parameters', () => {
-    const interfaceMirror = new InterfaceMirrorBuilder()
-      .addMethod(
-        new MethodMirrorBuilder()
-          .withName('sampleMethod')
-          .withTypeReference({
-            type: 'String',
-            rawDeclaration: 'String',
-          })
-          .build(),
-      )
-      .build();
-
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror);
-
-    expect(interfaceSource.methods).toHaveLength(1);
-    expect(interfaceSource.methods![0].signature).toBe('public String sampleMethod()');
-  });
-
-  it('converts method declarations. Method with parameters', () => {
-    const interfaceMirror = new InterfaceMirrorBuilder()
-      .addMethod(
-        new MethodMirrorBuilder()
-          .withName('sampleMethod')
-          .withTypeReference({
-            type: 'String',
-            rawDeclaration: 'String',
-          })
-          .addParameter(
-            new ParameterBuilder()
-              .withName('param1')
-              .withTypeReference({
-                type: 'String',
-                rawDeclaration: 'String',
-              })
-              .build(),
-          )
-          .build(),
-      )
-      .build();
-
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror);
-
-    expect(interfaceSource.methods).toHaveLength(1);
-    expect(interfaceSource.methods![0].signature).toBe('public String sampleMethod(String param1)');
-  });
-});

package/src/adapters/apex-types.ts

@@ -1,67 +0,0 @@
-import { ClassMirror, EnumMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
-import { BaseTypeSource, ClassSource, EnumSource, InterfaceSource } from '../templating/types';
-import { adaptDescribable, adaptDocumentable } from './documentables';
-import { linkFromTypeNameGenerator } from './references';
-import { FieldMirrorWithInheritance } from '../model/inheritance';
-import { adaptConstructor, adaptMethod } from './methods-and-constructors';
-import { adaptField } from './fields-and-properties';
-
-function baseTypeAdapter(type: EnumMirror | InterfaceMirror | ClassMirror): BaseTypeSource {
-  function extractAnnotationBody(type: Type, annotationName: string): string | undefined {
-    return type.docComment?.annotations.find(
-      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName,
-    )?.body;
-  }
-
-  function extractSeeAnnotations(type: Type): string[] {
-    return (
-      type.docComment?.annotations
-        .filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === 'see')
-        .map((currentAnnotation) => currentAnnotation.body) ?? []
-    );
-  }
-
-  return {
-    ...adaptDocumentable(type),
-    accessModifier: type.access_modifier,
-    name: type.name,
-    group: extractAnnotationBody(type, 'group'),
-    author: extractAnnotationBody(type, 'author'),
-    date: extractAnnotationBody(type, 'date'),
-    sees: extractSeeAnnotations(type).map(linkFromTypeNameGenerator),
-  };
-}
-
-export function enumTypeToEnumSource(enumType: EnumMirror): EnumSource {
-  return {
-    __type: 'enum',
-    ...baseTypeAdapter(enumType),
-    values: enumType.values.map((value) => ({
-      ...adaptDescribable(value.docComment?.descriptionLines),
-      value: value.name,
-    })),
-  };
-}
-
-export function interfaceTypeToInterfaceSource(interfaceType: InterfaceMirror): InterfaceSource {
-  return {
-    __type: 'interface',
-    ...baseTypeAdapter(interfaceType),
-    extends: interfaceType.extended_interfaces.map(linkFromTypeNameGenerator),
-    methods: interfaceType.methods.map(adaptMethod),
-  };
-}
-
-export function classTypeToClassSource(classType: ClassMirror): ClassSource {
-  return {
-    __type: 'class',
-    ...baseTypeAdapter(classType),
-    classModifier: classType.classModifier,
-    sharingModifier: classType.sharingModifier,
-    implements: classType.implemented_interfaces.map(linkFromTypeNameGenerator),
-    extends: classType.extended_class ? linkFromTypeNameGenerator(classType.extended_class) : undefined,
-    methods: classType.methods.map(adaptMethod),
-    constructors: classType.constructors.map((constructor) => adaptConstructor(classType.name, constructor)),
-    fields: classType.fields.map((field) => adaptField(field as FieldMirrorWithInheritance)),
-  };
-}

package/src/adapters/documentables.ts

@@ -1,58 +0,0 @@
-import { CustomTag, DocumentableSource, RenderableContent } from '../templating/types';
-import { Describable, Documentable } from './types';
-import { replaceInlineReferences } from './references';
-import { isEmptyLine } from './type-utils';
-
-export function adaptDescribable(describable: Describable): { description?: RenderableContent[] } {
-  function describableToRenderableContent(describable: Describable): RenderableContent[] | undefined {
-    if (!describable) {
-      return;
-    }
-
-    return (
-      describable
-        .map<RenderableContent[]>((line) => [
-          ...replaceInlineReferences(line),
-          {
-            type: 'empty-line',
-          },
-        ])
-        .flatMap((line) => line)
-        // If the last element is an empty line, remove it
-        .filter((line, index, lines) => !(isEmptyLine(line) && index === lines.length - 1))
-    );
-  }
-
-  return {
-    description: describableToRenderableContent(describable),
-  };
-}
-
-export function adaptDocumentable(documentable: Documentable): DocumentableSource {
-  function extractCustomTags(type: Documentable): CustomTag[] {
-    const baseTags = ['description', 'group', 'author', 'date', 'see', 'example', 'mermaid', 'throws', 'exception'];
-
-    return (
-      type.docComment?.annotations
-        .filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase()))
-        .map<CustomTag>((currentAnnotation) => ({
-          ...adaptDescribable(currentAnnotation.bodyLines),
-          name: currentAnnotation.name,
-        })) ?? []
-    );
-  }
-
-  function extractAnnotationBodyLines(type: Documentable, annotationName: string): string[] | undefined {
-    return type.docComment?.annotations.find(
-      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName,
-    )?.bodyLines;
-  }
-
-  return {
-    ...adaptDescribable(documentable.docComment?.descriptionLines),
-    annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
-    customTags: extractCustomTags(documentable),
-    mermaid: extractAnnotationBodyLines(documentable, 'mermaid'),
-    example: documentable.docComment?.exampleAnnotation?.bodyLines,
-  };
-}

package/src/adapters/fields-and-properties.ts

@@ -1,14 +0,0 @@
-import { FieldMirrorWithInheritance } from '../model/inheritance';
-import { FieldSource } from '../templating/types';
-import { adaptDocumentable } from './documentables';
-import { linkFromTypeNameGenerator } from './references';
-
-export function adaptField(field: FieldMirrorWithInheritance): FieldSource {
-  return {
-    ...adaptDocumentable(field),
-    name: field.name,
-    type: linkFromTypeNameGenerator(field.typeReference.rawDeclaration),
-    inherited: field.inherited,
-    accessModifier: field.access_modifier,
-  };
-}

package/src/adapters/methods-and-constructors.ts

@@ -1,78 +0,0 @@
-import { ConstructorMirror, MethodMirror, ParameterMirror, ThrowsAnnotation } from '@cparra/apex-reflection';
-import { ConstructorSource, MethodSource } from '../templating/types';
-import { MethodMirrorWithInheritance } from '../model/inheritance';
-import { adaptDescribable, adaptDocumentable } from './documentables';
-import { linkFromTypeNameGenerator } from './references';
-import { Documentable } from './types';
-
-export function adaptMethod(method: MethodMirror): MethodSource {
-  function buildTitle(method: MethodMirrorWithInheritance): string {
-    const { name, parameters } = method;
-    const parametersString = parameters.map((param) => param.name).join(', ');
-    return `${name}(${parametersString})`;
-  }
-
-  function buildSignature(method: MethodMirrorWithInheritance): string {
-    const { access_modifier, typeReference, name, memberModifiers } = method;
-    const parameters = method.parameters
-      .map((param) => `${param.typeReference.rawDeclaration} ${param.name}`)
-      .join(', ');
-    const members = memberModifiers.length > 0 ? `${memberModifiers.join(' ')} ` : '';
-    return `${access_modifier} ${members}${typeReference.rawDeclaration} ${name}(${parameters})`;
-  }
-
-  return {
-    ...adaptDocumentable(method),
-    title: buildTitle(method as MethodMirrorWithInheritance),
-    signature: buildSignature(method as MethodMirrorWithInheritance),
-    returnType: {
-      ...adaptDescribable(method.docComment?.returnAnnotation?.bodyLines),
-      type: linkFromTypeNameGenerator(method.typeReference.rawDeclaration),
-    },
-    throws: method.docComment?.throwsAnnotations.map((thrown) => mapThrows(thrown)),
-    parameters: method.parameters.map((param) => mapParameters(method, param)),
-    inherited: (method as MethodMirrorWithInheritance).inherited,
-  };
-}
-
-export function adaptConstructor(typeName: string, constructor: ConstructorMirror): ConstructorSource {
-  function buildTitle(name: string, constructor: ConstructorMirror): string {
-    const { parameters } = constructor;
-    const parametersString = parameters.map((param) => param.name).join(', ');
-    return `${name}(${parametersString})`;
-  }
-
-  function buildSignature(name: string, constructor: ConstructorMirror): string {
-    const { access_modifier } = constructor;
-    const parameters = constructor.parameters
-      .map((param) => `${param.typeReference.rawDeclaration} ${param.name}`)
-      .join(', ');
-    return `${access_modifier} ${name}(${parameters})`;
-  }
-
-  return {
-    ...adaptDocumentable(constructor),
-    title: buildTitle(typeName, constructor),
-    signature: buildSignature(typeName, constructor),
-    parameters: constructor.parameters.map((param) => mapParameters(constructor, param)),
-    throws: constructor.docComment?.throwsAnnotations.map((thrown) => mapThrows(thrown)),
-  };
-}
-
-function mapParameters(documentable: Documentable, param: ParameterMirror) {
-  const paramAnnotation = documentable.docComment?.paramAnnotations.find(
-    (pa) => pa.paramName.toLowerCase() === param.name.toLowerCase(),
-  );
-  return {
-    ...adaptDescribable(paramAnnotation?.bodyLines),
-    name: param.name,
-    type: linkFromTypeNameGenerator(param.typeReference.rawDeclaration),
-  };
-}
-
-function mapThrows(thrown: ThrowsAnnotation) {
-  return {
-    ...adaptDescribable(thrown.bodyLines),
-    type: linkFromTypeNameGenerator(thrown.exceptionName),
-  };
-}

package/src/adapters/type-utils.ts

@@ -1,5 +0,0 @@
-import { EmptyLine, RenderableContent } from '../templating/types';
-
-export function isEmptyLine(content: RenderableContent): content is EmptyLine {
-  return Object.keys(content).includes('type') && (content as { type: string }).type === 'empty-line';
-}

package/src/adapters/types.d.ts

@@ -1,8 +0,0 @@
-import { Annotation, DocComment } from '@cparra/apex-reflection';
-
-export type Describable = string[] | undefined;
-
-export type Documentable = {
-  annotations: Annotation[];
-  docComment?: DocComment;
-};

package/src/model/apex-bundle.ts

@@ -1,3 +0,0 @@
-export default class ApexBundle {
-  constructor(public filePath: string, public rawTypeContent: string, public rawMetadataContent: string | null) {}
-}

package/src/model/inheritance.ts

@@ -1,7 +0,0 @@
-import { FieldMirror, MethodMirror, PropertyMirror } from '@cparra/apex-reflection';
-
-export type InheritanceSupport = { inherited: boolean };
-export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
-export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
-export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
-export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;

package/src/model/manifest.ts

@@ -1,74 +0,0 @@
-import {
-  ClassMirror,
-  EnumMirror,
-  InterfaceMirror,
-  Type,
-  Annotation,
-  DocComment,
-  DocCommentAnnotation,
-} from '@cparra/apex-reflection';
-
-type AccessAndDocAware = { access_modifier: string; annotations: Annotation[]; docComment?: DocComment };
-
-/**
- * Represents the full library of Apex top-level types (classes, enums, and interface) for a Salesforce project.
- */
-export default class Manifest {
-  /**
-   * Constructs a new Manifest object.
-   * @param types List of types to be wrapped by this object.
-   * @param isForInnerTypes Whether this manifest represent an inner type or not.
-   */
-  constructor(public types: Type[], public isForInnerTypes: boolean = false) {}
-
-  filteredByAccessModifierAndAnnotations(modifiers: string[]): Type[] {
-    const filteredTypes = this.filterAccessibleModifier(this.types, modifiers);
-    const typesToReturn: Type[] = [];
-    for (const filteredType of filteredTypes) {
-      const currentType = filteredType as Type;
-      if (currentType.type_name !== 'class') {
-        typesToReturn.push(currentType);
-        continue;
-      }
-
-      const currentClass = currentType as ClassMirror;
-      let filteredClass = {
-        ...currentType,
-        methods: this.filterAccessibleModifier(currentClass.methods, modifiers),
-        properties: this.filterAccessibleModifier(currentClass.properties, modifiers),
-        fields: this.filterAccessibleModifier(currentClass.fields, modifiers),
-        constructors: this.filterAccessibleModifier(currentClass.constructors, modifiers),
-      } as ClassMirror;
-
-      if (!this.isForInnerTypes) {
-        filteredClass = {
-          ...filteredClass,
-          enums: this.filterAccessibleModifier(currentClass.enums, modifiers) as EnumMirror[],
-          interfaces: this.filterAccessibleModifier(currentClass.interfaces, modifiers) as InterfaceMirror[],
-          classes: new Manifest(currentClass.classes, true).filteredByAccessModifierAndAnnotations(
-            modifiers,
-          ) as ClassMirror[],
-        };
-      }
-
-      typesToReturn.push(filteredClass);
-    }
-
-    return typesToReturn;
-  }
-
-  filterAccessibleModifier(accessAndDocAware: AccessAndDocAware[], modifiers: string[]) {
-    return accessAndDocAware.filter((currentType) => {
-      const hasIgnoreDocAnnotation = currentType.docComment?.annotations.some(
-        (annotation: DocCommentAnnotation) => annotation.name === 'ignore',
-      );
-      if (hasIgnoreDocAnnotation) {
-        return false;
-      }
-      return (
-        modifiers.includes(currentType.access_modifier) ||
-        currentType.annotations.some((annotation: Annotation) => modifiers.includes(annotation.type.toLowerCase()))
-      );
-    });
-  }
-}

package/src/model/markdown-file.ts

@@ -1,121 +0,0 @@
-import { OutputFile } from './outputFile';
-import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
-
-export class MarkdownFile extends OutputFile {
-  fileExtension(): string {
-    return '.md';
-  }
-
-  addTitle(text: string, level = 1) {
-    let title = '';
-    for (let i = 0; i < level; i++) {
-      title += '#';
-    }
-
-    title += ' ';
-    title += text;
-    this._contents += title;
-    this.addBlankLine();
-  }
-
-  public addText(text: string, encodeHtml = true) {
-    super.addText(this._replaceInlineReferences(text), encodeHtml);
-  }
-
-  public addLink(text: string, encodeHtml = true) {
-    this.addText(`\{@link ${text}\}`, encodeHtml);
-  }
-
-  startCodeBlock(language = 'apex') {
-    this.addText(`\`\`\`${language}`);
-  }
-
-  endCodeBlock() {
-    this.addText('```');
-    this.addBlankLine();
-  }
-
-  addHorizontalRule() {
-    this._contents += '---';
-    this.addBlankLine();
-  }
-
-  initializeTable(...headers: string[]) {
-    this.addBlankLine();
-    this._contents += '|';
-    headers.forEach((header) => {
-      this._contents += header + '|';
-    });
-    this.addBlankLine();
-    this._contents += '|';
-    headers.forEach(() => {
-      this._contents += '---' + '|';
-    });
-    this.addBlankLine();
-  }
-
-  addTableRow(...columns: string[]) {
-    this._contents += '|';
-    columns.forEach((column) => {
-      this._contents += this._replaceInlineReferences(column) + '|';
-    });
-    this.addBlankLine();
-  }
-
-  addListItem(text: string) {
-    this._contents += `* ${text}`;
-  }
-
-  protected static replaceInlineLinks(text: string) {
-    // Parsing text to extract possible linking classes.
-    const possibleLinks = text.match(/<<.*?>>/g);
-    possibleLinks?.forEach((currentMatch) => {
-      const classNameForMatch = currentMatch.replace('<<', '').replace('>>', '');
-      text = text.replace(currentMatch, ClassFileGeneratorHelper.getFileLinkByTypeName(classNameForMatch));
-    });
-
-    // Parsing links using {@link ClassName} format
-    const linkFormatRegEx = '{@link (.*?)}';
-    const expression = new RegExp(linkFormatRegEx, 'gi');
-    let match;
-    const matches = [];
-
-    do {
-      match = expression.exec(text);
-      if (match) {
-        matches.push(match);
-      }
-    } while (match);
-
-    for (const currentMatch of matches) {
-      text = text.replace(currentMatch[0], ClassFileGeneratorHelper.getFileLinkByTypeName(currentMatch[1]));
-    }
-    return text;
-  }
-
-  protected static replaceInlineEmails(text: string) {
-    // Parsing links using {@link ClassName} format
-    const linkFormatRegEx = '{@email (.*?)}';
-    const expression = new RegExp(linkFormatRegEx, 'gi');
-    let match;
-    const matches = [];
-
-    do {
-      match = expression.exec(text);
-      if (match) {
-        matches.push(match);
-      }
-    } while (match);
-
-    for (const currentMatch of matches) {
-      text = text.replace(currentMatch[0], `[${currentMatch[1]}](mailto:${currentMatch[1]})`);
-    }
-    return text;
-  }
-
-  private _replaceInlineReferences(text: string): string {
-    text = MarkdownFile.replaceInlineLinks(text);
-    text = MarkdownFile.replaceInlineEmails(text);
-    return text;
-  }
-}

package/src/model/markdown-generation-util/doc-comment-annotation-util.ts

@@ -1,50 +0,0 @@
-import { DocComment, DocCommentAnnotation } from '@cparra/apex-reflection';
-import ClassFileGeneratorHelper from '../../transpiler/markdown/class-file-generatorHelper';
-import { MarkdownFile } from '../markdown-file';
-
-interface DocCommentAware {
-  docComment?: DocComment;
-}
-
-export function addMermaid(markdownFile: MarkdownFile, docCommentAware: DocCommentAware) {
-  const mermaid = docCommentAware.docComment?.annotations.find((annotation) => annotation.name === 'mermaid');
-  if (!mermaid) {
-    return;
-  }
-
-  markdownFile.addBlankLine();
-  markdownFile.startCodeBlock('mermaid');
-  mermaid.bodyLines.forEach((line) => {
-    markdownFile.addText(line, false);
-  });
-  markdownFile.endCodeBlock();
-  markdownFile.addBlankLine();
-}
-
-export function addCustomDocCommentAnnotations(markdownFile: MarkdownFile, docCommentAware: DocCommentAware) {
-  docCommentAware.docComment?.annotations
-    .filter((currentAnnotation: DocCommentAnnotation) => currentAnnotation.name !== 'description')
-    .filter((currentAnnotation: DocCommentAnnotation) => currentAnnotation.name !== 'mermaid')
-    .forEach((currentAnnotation: DocCommentAnnotation) => {
-      markdownFile.addBlankLine();
-      markdownFile.addText(buildDocAnnotationText(currentAnnotation));
-      markdownFile.addBlankLine();
-    });
-
-  function splitAndCapitalize(text: string) {
-    const words = text.split(/[-_]+/);
-    const capitalizedWords = [];
-    for (const word of words) {
-      capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
-    }
-    return capitalizedWords.join(' ');
-  }
-
-  function buildDocAnnotationText(annotation: DocCommentAnnotation) {
-    let annotationBodyText = annotation.body;
-    if (annotation.name.toLowerCase() === 'see') {
-      annotationBodyText = ClassFileGeneratorHelper.getFileLinkByTypeName(annotation.body);
-    }
-    return `**${splitAndCapitalize(annotation.name)}** ${annotationBodyText}`;
-  }
-}

package/src/model/markdown-generation-util/field-declaration-util.ts

@@ -1,71 +0,0 @@
-import { MarkdownFile } from '../markdown-file';
-import { FieldMirrorWithInheritance, FieldOrProperty, PropertyMirrorWithInheritance } from '../inheritance';
-
-export function declareField(
-  markdownFile: MarkdownFile,
-  fields: FieldMirrorWithInheritance[] | PropertyMirrorWithInheritance[],
-  startingHeadingLevel: number,
-  grouped = false,
-) {
-  markdownFile.addBlankLine();
-  fields.forEach((propertyModel) => {
-    addFieldSection(markdownFile, propertyModel, startingHeadingLevel, grouped);
-  });
-
-  markdownFile.addHorizontalRule();
-}
-
-function addFieldSection(
-  markdownFile: MarkdownFile,
-  mirrorModel: FieldOrProperty,
-  startingHeadingLevel: number,
-  grouped: boolean,
-) {
-  if (!grouped) {
-    markdownFile.addTitle(
-      `\`${mirrorModel.access_modifier} ${mirrorModel.name}\` → \`${mirrorModel.typeReference.rawDeclaration}\``,
-      startingHeadingLevel + 2,
-    );
-    markdownFile.addBlankLine();
-    if (mirrorModel.inherited) {
-      markdownFile.addText('*Inherited*');
-    }
-
-    mirrorModel.annotations.forEach((annotation) => {
-      markdownFile.addText(`\`${annotation.type.toUpperCase()}\` `);
-    });
-
-    if (mirrorModel.docComment?.description) {
-      markdownFile.addBlankLine();
-      markdownFile.addText(mirrorModel.docComment.description);
-    }
-    markdownFile.addBlankLine();
-  } else {
-    let annotations = '';
-    const hasAnnotations = !!mirrorModel.annotations.length;
-    if (hasAnnotations) {
-      annotations += ' [';
-    }
-    mirrorModel.annotations.forEach((annotation) => {
-      annotations += `\`${annotation.type.toUpperCase()}\` `;
-    });
-    if (hasAnnotations) {
-      annotations += ']';
-    }
-
-    // If grouped we want to display these as a list
-    let description = '';
-    if (mirrorModel.docComment?.description) {
-      description = ` - ${mirrorModel.docComment?.description}`;
-    }
-
-    let listItemText = `\`${mirrorModel.access_modifier} ${mirrorModel.name}\` → \`${mirrorModel.typeReference.rawDeclaration}\``;
-    if (mirrorModel.inherited) {
-      listItemText += '(*Inherited*)';
-    }
-    listItemText += `${annotations} ${description}`;
-
-    markdownFile.addListItem(listItemText);
-    markdownFile.addBlankLine();
-  }
-}

package/src/model/markdown-generation-util/index.ts

@@ -1,3 +0,0 @@
-export * from './type-declaration-util';
-export * from './method-declaration-util';
-export * from './field-declaration-util';