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

package/src/cli/generate.ts

@@ -1,140 +1,16 @@
 #!/usr/bin/env node
-import * as yargs from 'yargs';
-
-import { Settings } from '../settings';
 import { Apexdocs } from '../application/Apexdocs';
-import { GeneratorChoices } from '../transpiler/generator-choices';
-import { cosmiconfig } from 'cosmiconfig';
+import { extractArgs } from './args';
 
-const result = cosmiconfig('apexdocs').search();
-result.then((config) => {
-  yargs.config(config?.config);
-  let argv = yargs
-    .options({
-      sourceDir: {
-        type: 'string',
-        alias: 's',
-        demandOption: true,
-        describe: 'The directory location which contains your apex .cls classes.',
-      },
-      targetDir: {
-        type: 'string',
-        alias: 't',
-        default: './docs/',
-        describe: 'The directory location where documentation will be generated to.',
-      },
-      recursive: {
-        type: 'boolean',
-        alias: 'r',
-        default: true,
-        describe: 'Whether .cls classes will be searched for recursively in the directory provided.',
-      },
-      scope: {
-        type: 'string',
-        array: true,
-        alias: 'p',
-        default: ['global'],
-        describe:
-          'A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. ' +
-          'Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled. ' +
-          'Note that this setting is ignored if generating an OpenApi REST specification since that looks for classes annotated with @RestResource.',
-      },
-      targetGenerator: {
-        type: 'string',
-        alias: 'g',
-        default: 'jekyll',
-        choices: ['jekyll', 'docsify', 'plain-markdown', 'openapi'],
-        describe:
-          'Define the static file generator for which the documents will be created. ' +
-          'Currently supports jekyll, docsify, plain markdown, and OpenAPI v3.1.0.',
-      },
-      indexOnly: {
-        type: 'boolean',
-        default: false,
-        describe: 'Defines whether only the index file should be generated.',
-      },
-      defaultGroupName: {
-        type: 'string',
-        default: 'Miscellaneous',
-        describe: 'Defines the @group name to be used when a file does not specify it.',
-      },
-      sanitizeHtml: {
-        type: 'boolean',
-        default: true,
-        describe:
-          'When on, any special character within your ApexDocs is converted into its HTML code representation. ' +
-          'This is specially useful when generic objects are described within the docs, e.g. "List< Foo>", "Map<Foo, Bar>" ' +
-          'because otherwise the content within < and > would be treated as HTML tags and not shown in the output. ' +
-          'Content in @example blocks are never sanitized.',
-      },
-      openApiTitle: {
-        type: 'string',
-        default: 'Apex REST Api',
-        describe: 'If using "openapi" as the target generator, this allows you to specify the OpenApi title value.',
-      },
-      title: {
-        type: 'string',
-        describe: "If this allows you to specify the title of the generated documentation's home file.",
-        default: 'Classes',
-      },
-      namespace: {
-        type: 'string',
-        describe:
-          'The package namespace, if any. If this value is provided the namespace will be added as a prefix to all of the parsed files. ' +
-          "If generating an OpenApi definition, it will be added to the file's Server Url.",
-      },
-      openApiFileName: {
-        type: 'string',
-        describe: 'If using "openapi" as the target generator, this allows you to specify the name of the output file.',
-        default: 'openapi',
-      },
-      sortMembersAlphabetically: {
-        type: 'boolean',
-        describe: 'Whether to sort members alphabetically.',
-        default: false,
-      },
-      includeMetadata: {
-        type: 'boolean',
-        describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
-        default: false,
-      },
-      documentationRootDir: {
-        type: 'string',
-        describe:
-          'Allows you to specify the root documentation directory where the files are being generated. This can be helpful when embedding the generated docs into an existing site so that the links are generated correctly.',
-      },
+function main() {
+  extractArgs()
+    .then((config) => {
+      Apexdocs.generate(config);
     })
-    .parseSync();
-
-  if (config) {
-    argv = { ...config.config, ...argv };
-  }
-
-  Settings.build({
-    sourceDirectory: argv.sourceDir,
-    recursive: argv.recursive,
-    scope: argv.scope,
-    outputDir: argv.targetDir,
-    targetGenerator: argv.targetGenerator as GeneratorChoices,
-    indexOnly: argv.indexOnly,
-    defaultGroupName: argv.defaultGroupName,
-    sanitizeHtml: argv.sanitizeHtml,
-    openApiTitle: argv.openApiTitle,
-    title: argv.title,
-    namespace: argv.namespace,
-    openApiFileName: argv.openApiFileName,
-    sortMembersAlphabetically: argv.sortMembersAlphabetically,
-    includeMetadata: argv.includeMetadata,
-    rootDir: argv.documentationRootDir,
-    onAfterProcess: config?.config?.onAfterProcess,
-    onBeforeFileWrite: config?.config?.onBeforeFileWrite,
-    frontMatterHeader: config?.config?.frontMatterHeader,
-  });
+    .catch((error) => {
+      console.error(error);
+      process.exit(1);
+    });
+}
 
-  try {
-    Apexdocs.generate();
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-});
+main();

package/src/{adapters → core/adapters}/__tests__/interface-adapter.spec.ts

@@ -1,7 +1,7 @@
-import { InterfaceMirrorBuilder } from '../../test-helpers/InterfaceMirrorBuilder';
-import { AnnotationBuilder } from '../../test-helpers/AnnotationBuilder';
-import { MethodMirrorBuilder, ParameterBuilder } from '../../test-helpers/MethodMirrorBuilder';
-import { interfaceTypeToInterfaceSource } from '../apex-types';
+import { typeToRenderable } from '../apex-types';
+import { InterfaceMirrorBuilder } from '../../../test-helpers/InterfaceMirrorBuilder';
+import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
+import { MethodMirrorBuilder, ParameterBuilder } from '../../../test-helpers/MethodMirrorBuilder';
 
 function linkGenerator(type: string): string {
   return type;
@@ -10,14 +10,14 @@ function linkGenerator(type: string): string {
 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, linkGenerator);
+    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
 
     expect(interfaceSource.name).toBe('SampleInterface');
   });
 
   it('converts the access modifier', () => {
     const interfaceMirror = new InterfaceMirrorBuilder().build();
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
 
     expect(interfaceSource.meta.accessModifier).toBe('public');
   });
@@ -26,7 +26,7 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
     const interfaceMirror = new InterfaceMirrorBuilder()
       .addAnnotation(new AnnotationBuilder().withName('MyAnnotation').build())
       .build();
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
 
     expect(interfaceSource.doc.annotations).toEqual(['MYANNOTATION']);
   });
@@ -44,10 +44,10 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
       )
       .build();
 
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
 
     expect(interfaceSource.methods.value).toHaveLength(1);
-    expect(interfaceSource.methods.value[0].signature.value[0]).toBe('public String sampleMethod()');
+    expect(interfaceSource.methods.value[0].signature.value.content[0]).toBe('public String sampleMethod()');
   });
 
   it('converts method declarations. Method with parameters', () => {
@@ -72,9 +72,11 @@ describe('Conversion from InterfaceMirror to InterfaceSource understandable by t
       )
       .build();
 
-    const interfaceSource = interfaceTypeToInterfaceSource(interfaceMirror, linkGenerator);
+    const interfaceSource = typeToRenderable(interfaceMirror, linkGenerator);
 
     expect(interfaceSource.methods.value).toHaveLength(1);
-    expect(interfaceSource.methods.value[0].signature.value[0]).toBe('public String sampleMethod(String param1)');
+    expect(interfaceSource.methods.value[0].signature.value.content[0]).toBe(
+      'public String sampleMethod(String param1)',
+    );
   });
 });

package/src/{adapters → core/adapters}/__tests__/references.spec.ts

@@ -1,8 +1,9 @@
 import { replaceInlineReferences } from '../references';
-import { Link } from '../../core/renderable/types';
+import { Link } from '../types';
 
 function getFileLink(typeName: string): Link {
   return {
+    __type: 'link' as const,
     title: typeName,
     url: `/api/${typeName}.html`,
   };
@@ -10,6 +11,7 @@ function getFileLink(typeName: string): Link {
 
 function getEmailLink(typeName: string) {
   return {
+    __type: 'link' as const,
     title: typeName,
     url: `mailto:${typeName}`,
   };
@@ -33,6 +35,7 @@ describe('reference utilities', () => {
       const expected = [
         'This is a test ',
         {
+          __type: 'link',
           title: 'ClassName',
           url: '/api/ClassName.html',
         },
@@ -44,6 +47,7 @@ describe('reference utilities', () => {
     it('replaces links in the format of {@link ClassName}', () => {
       function getFileLinkByTypeName(typeName: string): Link {
         return {
+          __type: 'link' as const,
           title: typeName,
           url: `/api/${typeName}.html`,
         };
@@ -55,6 +59,7 @@ describe('reference utilities', () => {
       const expected = [
         'This is a test ',
         {
+          __type: 'link',
           title: 'ClassName',
           url: '/api/ClassName.html',
         },
@@ -68,6 +73,7 @@ describe('reference utilities', () => {
     it('replaces emails in the format of {@email email-address}', () => {
       function getLinkByTypeName(typeName: string) {
         return {
+          __type: 'link' as const,
           title: typeName,
           url: `mailto:${typeName}`,
         };
@@ -79,6 +85,7 @@ describe('reference utilities', () => {
       const expected = [
         'This is an email ',
         {
+          __type: 'link',
           title: 'example@example.com',
           url: 'mailto:example@example.com',
         },
@@ -95,16 +102,19 @@ describe('reference utilities', () => {
     const expected = [
       'This is a test ',
       {
+        __type: 'link',
         title: 'ClassName',
         url: '/api/ClassName.html',
       },
       ', and ',
       {
+        __type: 'link',
         title: 'AnotherClass',
         url: '/api/AnotherClass.html',
       },
       ', and an email ',
       {
+        __type: 'link',
         title: 'testerson',
         url: 'mailto:testerson',
       },

package/src/{adapters → core/adapters}/apex-types.ts

@@ -4,38 +4,41 @@ import {
   RenderableClass,
   RenderableEnum,
   RenderableInterface,
-  Renderable,
   RenderableSection,
   GroupedMember,
-} from '../core/renderable/types';
-import { adaptDescribable, adaptDocumentable } from './documentables';
-import { GetRenderableContentByTypeName } from './references';
-import {
   ClassMirrorWithInheritanceChain,
   FieldMirrorWithInheritance,
   PropertyMirrorWithInheritance,
-} from '../model/inheritance';
+} from './types';
+import { adaptDescribable, adaptDocumentable } from './documentables';
+import { GetRenderableContentByTypeName } from './references';
 import { adaptConstructor, adaptMethod } from './methods-and-constructors';
 import { adaptFieldOrProperty } from './fields-and-properties';
 
-export function typeToRenderableType(
-  type: Type,
+type GetReturnRenderable<T extends Type> = T extends InterfaceMirror
+  ? RenderableInterface
+  : T extends ClassMirror
+    ? RenderableClass
+    : RenderableEnum;
+
+export function typeToRenderable<T extends Type>(
+  type: T,
   linkGenerator: GetRenderableContentByTypeName,
   namespace?: string,
-): Renderable {
-  function getRenderable() {
+): GetReturnRenderable<T> {
+  function getRenderable(): RenderableInterface | RenderableClass | RenderableEnum {
     switch (type.type_name) {
       case 'enum':
-        return enumTypeToEnumSource(type as EnumMirror, linkGenerator);
+        return enumTypeToEnumSource(type as EnumMirror, linkGenerator) as RenderableEnum;
       case 'interface':
-        return interfaceTypeToInterfaceSource(type as InterfaceMirror, linkGenerator);
+        return interfaceTypeToInterfaceSource(type as InterfaceMirror, linkGenerator) as RenderableInterface;
       case 'class':
-        return classTypeToClassSource(type as ClassMirrorWithInheritanceChain, linkGenerator);
+        return classTypeToClassSource(type as ClassMirrorWithInheritanceChain, linkGenerator) as RenderableClass;
     }
   }
 
   return {
-    ...getRenderable(),
+    ...(getRenderable() as GetReturnRenderable<T>),
     namespace,
   };
 }
@@ -85,7 +88,7 @@ function enumTypeToEnumSource(
   };
 }
 
-export function interfaceTypeToInterfaceSource(
+function interfaceTypeToInterfaceSource(
   interfaceType: InterfaceMirror,
   linkGenerator: GetRenderableContentByTypeName,
   baseHeadingLevel: number = 1,

package/src/core/adapters/documentables.ts

@@ -0,0 +1,195 @@
+import { CustomTag, RenderableDocumentation, RenderableContent, CodeBlock } from './types';
+import { Describable, Documentable } from './types';
+import { GetRenderableContentByTypeName, replaceInlineReferences } from './references';
+import { isEmptyLine } from './type-utils';
+
+export function adaptDescribable(
+  describable: Describable,
+  linkGenerator: GetRenderableContentByTypeName,
+): {
+  description?: RenderableContent[];
+} {
+  function describableToRenderableContent(describable: Describable): RenderableContent[] | undefined {
+    if (!describable) {
+      return;
+    }
+
+    let content: RenderableContent[] = [];
+    for (let i = 0; i < describable.length; i++) {
+      const line = describable[i];
+      // The language might or might not be present after ```
+      const codeBlockMatch = line.match(/^```([a-zA-Z]*)$/);
+      if (codeBlockMatch) {
+        // Check if the language is present, if not, fallback to "apex"
+        const language = codeBlockMatch[1] || 'apex';
+        const codeBlockLines: string[] = [];
+        i++;
+        while (i < describable.length) {
+          const currentLine = describable[i];
+          if (currentLine.trim() === '```') {
+            break;
+          }
+          codeBlockLines.push(currentLine);
+          i++;
+        }
+        console.log('codeBlockLines', codeBlockLines);
+        content = [
+          ...content,
+          {
+            __type: 'code-block',
+            language,
+            content: codeBlockLines,
+          },
+          { __type: 'empty-line' },
+        ];
+        continue;
+      }
+
+      content = [
+        ...content,
+        ...replaceInlineReferences(line, linkGenerator),
+        {
+          __type: 'empty-line',
+        },
+      ];
+    }
+    return (
+      content
+        .flatMap((line) => line)
+        // If the last element is an empty line, remove it
+        .filter((line, index, lines) => !(isEmptyLine(line) && index === lines.length - 1))
+    );
+
+    // TODO: Now we want to also extract code blocks if we encounter any line that starts with "```"
+
+    // return describable.reduce<RenderableContent[]>(
+    //   (acc, line) => {
+    //     if (line.trim() === '') {
+    //       return [...acc, { __type: 'empty-line' }];
+    //     }
+    //
+    //     // The language might or might not be present after ```
+    //     const codeBlockMatch = line.match(/^```([a-zA-Z]*)$/);
+    //     if (codeBlockMatch) {
+    //       console.log('codeBlockMatch', codeBlockMatch);
+    //       // Check if the language is present, if not, fallback to "apex"
+    //       const language = codeBlockMatch[1] || 'apex';
+    //       const codeBlockLines: string[] = [];
+    //       let index = acc.length + 1;
+    //       while (index < describable.length) {
+    //         const currentLine = describable[index];
+    //         if (currentLine.trim() === '```') {
+    //           break;
+    //         }
+    //         codeBlockLines.push(currentLine);
+    //         index++;
+    //       }
+    //       return [
+    //         ...acc,
+    //         {
+    //           __type: 'code-block',
+    //           language,
+    //           content: codeBlockLines,
+    //         },
+    //       ];
+    //     }
+    //
+    //     return [
+    //       ...acc,
+    //       ...replaceInlineReferences(line, linkGenerator),
+    //       {
+    //         __type: 'empty-line',
+    //       },
+    //     ];
+    //   },
+    //   <RenderableContent[]>[],
+    // );
+
+    // return (
+    //   describable
+    //     .map<RenderableContent[]>((line) => [
+    //       ...replaceInlineReferences(line, linkGenerator),
+    //       {
+    //         __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,
+  linkGenerator: GetRenderableContentByTypeName,
+  subHeadingLevel: number,
+): RenderableDocumentation {
+  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, linkGenerator),
+          name: currentAnnotation.name,
+        })) ?? []
+    );
+  }
+
+  function extractAnnotationBodyLines(type: Documentable, annotationName: string): string[] | undefined {
+    return type.docComment?.annotations.find(
+      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName,
+    )?.bodyLines;
+  }
+
+  function extractAnnotationBody(type: Documentable, annotationName: string): string | undefined {
+    return type.docComment?.annotations.find(
+      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName,
+    )?.body;
+  }
+
+  function extractSeeAnnotations(type: Documentable): string[] {
+    return (
+      type.docComment?.annotations
+        .filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === 'see')
+        .map((currentAnnotation) => currentAnnotation.body) ?? []
+    );
+  }
+
+  function bodyLinesToCodeBlock(language: string, bodyLines: string[] | undefined): CodeBlock | undefined {
+    if (!bodyLines) {
+      return;
+    }
+    return {
+      __type: 'code-block',
+      language,
+      content: bodyLines,
+    };
+  }
+
+  return {
+    ...adaptDescribable(documentable.docComment?.descriptionLines, linkGenerator),
+    annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
+    customTags: extractCustomTags(documentable),
+    mermaid: {
+      headingLevel: subHeadingLevel,
+      heading: 'Diagram',
+      value: bodyLinesToCodeBlock('mermaid', extractAnnotationBodyLines(documentable, 'mermaid')),
+    },
+    example: {
+      headingLevel: subHeadingLevel,
+      heading: 'Example',
+      value: bodyLinesToCodeBlock('apex', documentable.docComment?.exampleAnnotation?.bodyLines),
+    },
+    group: extractAnnotationBody(documentable, 'group'),
+    author: extractAnnotationBody(documentable, 'author'),
+    date: extractAnnotationBody(documentable, 'date'),
+    sees: extractSeeAnnotations(documentable).map(linkGenerator),
+  };
+}

package/src/{adapters → core/adapters}/fields-and-properties.ts

@@ -1,5 +1,4 @@
-import { FieldMirrorWithInheritance, PropertyMirrorWithInheritance } from '../model/inheritance';
-import { RenderableField } from '../core/renderable/types';
+import { CodeBlock, FieldMirrorWithInheritance, PropertyMirrorWithInheritance, RenderableField } from './types';
 import { adaptDocumentable } from './documentables';
 import { GetRenderableContentByTypeName } from './references';
 
@@ -8,14 +7,17 @@ export function adaptFieldOrProperty(
   linkGenerator: GetRenderableContentByTypeName,
   baseHeadingLevel: number,
 ): RenderableField {
-  function buildSignature() {
+  function buildSignature(): CodeBlock {
     const { access_modifier, name } = field;
     const memberModifiers = field.memberModifiers.join(' ');
-    return (
-      `${access_modifier} ${memberModifiers} ${name}`
-        // remove double spaces
-        .replace(/ {2}/g, ' ')
-    );
+    const codeContents = `${access_modifier} ${memberModifiers} ${name}`
+      // remove double spaces
+      .replace(/ {2}/g, ' ');
+    return {
+      __type: 'code-block',
+      language: 'apex',
+      content: [codeContents],
+    };
   }
 
   return {
@@ -32,7 +34,7 @@ export function adaptFieldOrProperty(
     signature: {
       headingLevel: baseHeadingLevel + 1,
       heading: 'Signature',
-      value: [buildSignature()],
+      value: buildSignature(),
     },
   };
 }

package/src/{adapters → core/adapters}/methods-and-constructors.ts

@@ -1,6 +1,5 @@
 import { ConstructorMirror, MethodMirror, ParameterMirror, ThrowsAnnotation } from '@cparra/apex-reflection';
-import { RenderableConstructor, RenderableMethod } from '../core/renderable/types';
-import { MethodMirrorWithInheritance } from '../model/inheritance';
+import { RenderableConstructor, RenderableMethod, MethodMirrorWithInheritance, CodeBlock } from './types';
 import { adaptDescribable, adaptDocumentable } from './documentables';
 import { GetRenderableContentByTypeName } from './references';
 import { Documentable } from './types';
@@ -16,13 +15,17 @@ export function adaptMethod(
     return `${name}(${parametersString})`;
   }
 
-  function buildSignature(method: MethodMirrorWithInheritance): string {
+  function buildSignature(method: MethodMirrorWithInheritance): CodeBlock {
     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 {
+      __type: 'code-block',
+      language: 'apex',
+      content: [`${access_modifier} ${members}${typeReference.rawDeclaration} ${name}(${parameters})`],
+    };
   }
 
   return {
@@ -32,7 +35,7 @@ export function adaptMethod(
     signature: {
       headingLevel: baseHeadingLevel + 1,
       heading: 'Signature',
-      value: [buildSignature(method as MethodMirrorWithInheritance)],
+      value: buildSignature(method as MethodMirrorWithInheritance),
     },
     returnType: {
       headingLevel: baseHeadingLevel + 1,
@@ -68,12 +71,16 @@ export function adaptConstructor(
     return `${name}(${parametersString})`;
   }
 
-  function buildSignature(name: string, constructor: ConstructorMirror): string {
+  function buildSignature(name: string, constructor: ConstructorMirror): CodeBlock {
     const { access_modifier } = constructor;
     const parameters = constructor.parameters
       .map((param) => `${param.typeReference.rawDeclaration} ${param.name}`)
       .join(', ');
-    return `${access_modifier} ${name}(${parameters})`;
+    return {
+      __type: 'code-block',
+      language: 'apex',
+      content: [`${access_modifier} ${name}(${parameters})`],
+    };
   }
 
   return {
@@ -83,7 +90,7 @@ export function adaptConstructor(
     signature: {
       headingLevel: baseHeadingLevel + 1,
       heading: 'Signature',
-      value: [buildSignature(typeName, constructor)],
+      value: buildSignature(typeName, constructor),
     },
     parameters: {
       headingLevel: baseHeadingLevel + 1,

package/src/{adapters → core/adapters}/references.ts

@@ -1,13 +1,10 @@
-import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
-import { Link, RenderableContent, StringOrLink } from '../core/renderable/types';
+import { Link, RenderableContent, StringOrLink } from './types';
 
 export type GetRenderableContentByTypeName = (typeName: string) => StringOrLink;
 
-export const linkFromTypeNameGenerator: GetRenderableContentByTypeName =
-  ClassFileGeneratorHelper.getRenderableLinkByTypeName;
-
 function defaultGetEmailByReference(email: string): Link {
   return {
+    __type: 'link',
     title: email,
     url: `mailto:${email}`,
   };
@@ -15,7 +12,7 @@ function defaultGetEmailByReference(email: string): Link {
 
 export function replaceInlineReferences(
   text: string,
-  linkReplacer: GetRenderableContentByTypeName = linkFromTypeNameGenerator,
+  linkReplacer: GetRenderableContentByTypeName,
   emailReplacer: GetRenderableContentByTypeName = defaultGetEmailByReference,
 ): RenderableContent[] {
   return replaceInlineEmails(replaceInlineLinks([text], linkReplacer), emailReplacer);