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

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

@@ -1,13 +1,14 @@
-import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
-import { Link, RenderableContent, StringOrLink } from '../core/renderable/types';
+import { InlineCode, Link, RenderableContent } from './types';
+import { pipe } from 'fp-ts/function';
+import { apply } from '../../util/fp';
 
-export type GetRenderableContentByTypeName = (typeName: string) => StringOrLink;
+type InlineRenderableContent = InlineCode | Link | string;
 
-export const linkFromTypeNameGenerator: GetRenderableContentByTypeName =
-  ClassFileGeneratorHelper.getRenderableLinkByTypeName;
+type ToInlineRenderableContent = (typeName: string) => InlineRenderableContent;
 
 function defaultGetEmailByReference(email: string): Link {
   return {
+    __type: 'link',
     title: email,
     url: `mailto:${email}`,
   };
@@ -15,22 +16,51 @@ function defaultGetEmailByReference(email: string): Link {
 
 export function replaceInlineReferences(
   text: string,
-  linkReplacer: GetRenderableContentByTypeName = linkFromTypeNameGenerator,
-  emailReplacer: GetRenderableContentByTypeName = defaultGetEmailByReference,
+  linkReplacer: ToInlineRenderableContent,
+  emailReplacer: ToInlineRenderableContent = defaultGetEmailByReference,
 ): RenderableContent[] {
-  return replaceInlineEmails(replaceInlineLinks([text], linkReplacer), emailReplacer);
+  const inlineLinks = apply(replaceInlineLinks, linkReplacer);
+  const inlineEmails = apply(replaceInlineEmails, emailReplacer);
+
+  return pipe(inlineCode([text]), inlineLinks, inlineEmails);
+}
+
+function inlineCode(renderableContents: RenderableContent[]): RenderableContent[] {
+  return renderableContents.flatMap((renderableContent) => inlineCodeContent(renderableContent));
+}
+
+// Replace string that is inline code with InlineCode
+// Inline code is any text that backticks surround
+function inlineCodeContent(renderableContent: RenderableContent): RenderableContent[] {
+  if (typeof renderableContent !== 'string') {
+    return [renderableContent];
+  }
+
+  function inlineCodeLink(text: string): InlineCode {
+    return {
+      __type: 'inline-code',
+      content: text,
+    };
+  }
+
+  const text = renderableContent;
+
+  // Matches any text surrounded by backticks
+  const codeFormatRegEx = '`([^`]*)`';
+  const matches = match(codeFormatRegEx, text);
+  return createRenderableContents(matches, text, inlineCodeLink);
 }
 
 function replaceInlineLinks(
+  getLinkByTypeName: ToInlineRenderableContent,
   renderableContents: RenderableContent[],
-  getLinkByTypeName: GetRenderableContentByTypeName,
 ): RenderableContent[] {
   return renderableContents.flatMap((renderableContent) => inlineLinkContent(renderableContent, getLinkByTypeName));
 }
 
 function inlineLinkContent(
   renderableContent: RenderableContent,
-  getLinkByTypeName: GetRenderableContentByTypeName,
+  getLinkByTypeName: ToInlineRenderableContent,
 ): RenderableContent[] {
   if (typeof renderableContent !== 'string') {
     return [renderableContent];
@@ -45,15 +75,15 @@ function inlineLinkContent(
 }
 
 export function replaceInlineEmails(
+  getLinkByTypeName: ToInlineRenderableContent,
   renderableContents: RenderableContent[],
-  getLinkByTypeName: GetRenderableContentByTypeName,
 ): RenderableContent[] {
   return renderableContents.flatMap((renderableContent) => inlineEmailContent(renderableContent, getLinkByTypeName));
 }
 
 function inlineEmailContent(
   renderableContent: RenderableContent,
-  getLinkByTypeName: GetRenderableContentByTypeName,
+  getLinkByTypeName: ToInlineRenderableContent,
 ): RenderableContent[] {
   if (typeof renderableContent !== 'string') {
     return [renderableContent];
@@ -82,7 +112,7 @@ function match(regex: string, text: string) {
   return matches;
 }
 
-function createRenderableContents(matches: RegExpExecArray[], text: string, linker: GetRenderableContentByTypeName) {
+function createRenderableContents(matches: RegExpExecArray[], text: string, linker: ToInlineRenderableContent) {
   if (matches.length === 0) {
     return [text];
   }

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

@@ -1,8 +1,12 @@
 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,
+  GetRenderableContentByTypeName,
+} from './types';
 import { adaptDescribable, adaptDocumentable } from './documentables';
-import { GetRenderableContentByTypeName } from './references';
 import { Documentable } from './types';
 
 export function adaptMethod(
@@ -16,13 +20,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 +40,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 +76,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 +95,7 @@ export function adaptConstructor(
     signature: {
       headingLevel: baseHeadingLevel + 1,
       heading: 'Signature',
-      value: [buildSignature(typeName, constructor)],
+      value: buildSignature(typeName, constructor),
     },
     parameters: {
       headingLevel: baseHeadingLevel + 1,

package/src/core/adapters/type-utils.ts

@@ -0,0 +1,13 @@
+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';
+}
+
+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/{renderable → adapters}/types.d.ts

@@ -1,15 +1,44 @@
+// Apex Reflection-based types
+import {
+  Annotation as MirrorAnnotation,
+  ClassMirror,
+  DocComment,
+  FieldMirror,
+  MethodMirror,
+  PropertyMirror,
+} from '@cparra/apex-reflection';
+
+export type Describable = string[] | undefined;
+
+export type Documentable = {
+  annotations: MirrorAnnotation[];
+  docComment?: DocComment;
+};
+
+export type InheritanceSupport = { inherited: boolean };
+export type ClassMirrorWithInheritanceChain = ClassMirror & { inheritanceChain: string[] };
+export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
+export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
+export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
+export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;
+
+// Renderable types
+
 export type Link = {
+  readonly __type: 'link';
   title: string;
   url: string;
 };
 
 export type EmptyLine = {
-  type: 'empty-line';
+  __type: 'empty-line';
 };
 
 export type StringOrLink = string | Link;
 
-export type RenderableContent = StringOrLink | EmptyLine;
+export type GetRenderableContentByTypeName = (typeName: string) => StringOrLink;
+
+export type RenderableContent = StringOrLink | EmptyLine | CodeBlock | InlineCode;
 
 type EnumValue = {
   value: string;
@@ -22,11 +51,20 @@ type CustomTag = {
 };
 
 /**
- * Represents an annotation to a top-level type. For example @NamespaceAccessible.
+ * Represents an annotation to a top-level type. For example, @NamespaceAccessible.
  */
 type Annotation = string;
 
-type CodeBlock = string[];
+type CodeBlock = {
+  readonly __type: 'code-block';
+  language: string;
+  content: string[];
+};
+
+type InlineCode = {
+  readonly __type: 'inline-code';
+  content: string;
+};
 
 type RenderableDocumentation = {
   annotations?: Annotation[];

package/src/core/generate-docs.ts

@@ -1,18 +1,22 @@
 import { ClassMirror, InterfaceMirror, reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
-import { typeToRenderableType } from '../adapters/apex-types';
-import { Link, Renderable, RenderableContent, RenderableEnum, StringOrLink } from './renderable/types';
-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 * as O from 'fp-ts/Option';
+import { pipe } from 'fp-ts/function';
 import * as E from 'fp-ts/Either';
-import { flow, pipe } from 'fp-ts/function';
+
+import { typeToRenderable } from './adapters/apex-types';
+import { Link, Renderable, RenderableContent, RenderableEnum, StringOrLink } from './adapters/types';
 import { CompilationRequest, Template } from './template';
-import Manifest from '../model/manifest';
 import { referenceGuideTemplate } from './templates/reference-guide';
-import { adaptDescribable } from '../adapters/documentables';
+import { adaptDescribable } from './adapters/documentables';
 import { createInheritanceChain } from './inheritance-chain';
+import ApexBundle from './apex-bundle';
+import Manifest from './manifest';
 
-export const documentType = flow(typeToRenderableType, resolveApexTypeTemplate, compile);
+// TODO: The core should never depend on things from the outside, so it should never reference "back" (../)
+import { classMarkdownTemplate } from '../transpiler/markdown/plain-markdown/class-template';
+import { interfaceMarkdownTemplate } from '../transpiler/markdown/plain-markdown/interface-template';
+import { enumMarkdownTemplate } from '../transpiler/markdown/plain-markdown/enum-template';
+import MetadataProcessor from '../service/metadata-processor';
 
 export type DocumentationBundle = {
   format: 'markdown';
@@ -44,13 +48,13 @@ const configDefaults: DocumentationConfig = {
 };
 
 export function generateDocs(
-  input: string[],
+  input: ApexBundle[],
   config?: Partial<DocumentationConfig>,
-): E.Either<string[], DocumentationBundle> {
+): E.Either<ReflectionError[], DocumentationBundle> {
   const configWithDefaults = { ...configDefaults, ...config };
   return pipe(
     input,
-    (input) => input.map(reflectSourceBody),
+    (input) => input.map((bundle) => reflectSourceBody(bundle)),
     checkForReflectionErrors,
     E.map((types) => filterTypesOutOfScope(types, configWithDefaults.scope)),
     E.map((types) => types.map((type) => addInheritedMembers(type, types))),
@@ -82,7 +86,7 @@ type RenderableBundle = {
 function typesToRenderableBundle(types: Type[], config: DocumentationConfig) {
   return types.reduce<RenderableBundle>(
     (acc, type) => {
-      const renderable = typeToRenderableType(
+      const renderable = typeToRenderable(
         type,
         (referenceName) => {
           return linkFromTypeNameGenerator(type, types, referenceName, config);
@@ -159,12 +163,12 @@ function filterTypesOutOfScope(types: Type[], scope: string[]): Type[] {
   return new Manifest(types).filteredByAccessModifierAndAnnotations(scope);
 }
 
-function checkForReflectionErrors(reflectionResult: E.Either<string, Type>[]) {
-  function reduceReflectionResultIntoSingleEither(results: E.Either<string, Type>[]): {
-    errors: string[];
+function checkForReflectionErrors(reflectionResult: E.Either<ReflectionError, Type>[]) {
+  function reduceReflectionResultIntoSingleEither(results: E.Either<ReflectionError, Type>[]): {
+    errors: ReflectionError[];
     types: Type[];
   } {
-    return results.reduce<{ errors: string[]; types: Type[] }>(
+    return results.reduce<{ errors: ReflectionError[]; types: Type[] }>(
       (acc, result) => {
         E.isLeft(result) ? acc.errors.push(result.left) : acc.types.push(result.right);
         return acc;
@@ -181,10 +185,39 @@ function checkForReflectionErrors(reflectionResult: E.Either<string, Type>[]) {
   );
 }
 
-function reflectSourceBody(input: string): E.Either<string, Type> {
+function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
+  return pipe(
+    O.fromNullable(metadata),
+    O.map((metadata) => {
+      const metadataParams = MetadataProcessor.process(metadata);
+      metadataParams.forEach((value, key) => {
+        const declaration = `${key}: ${value}`;
+        type.annotations.push({
+          rawDeclaration: declaration,
+          name: declaration,
+          type: declaration,
+        });
+      });
+      return type;
+    }),
+    O.getOrElse(() => type),
+  );
+}
+
+export class ReflectionError {
+  constructor(
+    public file: string,
+    public message: string,
+  ) {}
+}
+
+function reflectSourceBody(apexBundle: ApexBundle): E.Either<ReflectionError, Type> {
+  const { filePath, rawTypeContent: input, rawMetadataContent: metadata } = apexBundle;
   const result = mirrorReflection(input);
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return result.error ? E.left(result.error.message) : E.right(result.typeMirror!);
+  return result.error
+    ? E.left(new ReflectionError(filePath, result.error.message))
+    : E.right(addFileMetadataToTypeAnnotation(result.typeMirror!, metadata));
 }
 
 function resolveApexTypeTemplate(renderable: Renderable): CompilationRequest {
@@ -330,6 +363,7 @@ function linkFromTypeNameGenerator(
 
   const [fullClassName, fileLink] = getFileLinkTuple(typeBeingDocumented, type, config);
   return {
+    __type: 'link',
     title: fullClassName,
     url: fileLink,
   };
@@ -362,6 +396,7 @@ function getPossibleLinkFromRoot(config: DocumentationConfig, fallback: string,
   const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
   const title = `${namespacePrefix}${type.name}`;
   return {
+    __type: 'link',
     title: title,
     url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
   };
@@ -371,6 +406,7 @@ function getLinkFromRoot(config: DocumentationConfig, type: Type): Link {
   const namespacePrefix = config.namespace ? `${config.namespace}.` : '';
   const title = `${namespacePrefix}${type.name}`;
   return {
+    __type: 'link',
     title: title,
     url: `${getDirectoryFromRoot(config, type)}/${title}.md`,
   };

package/src/core/template.ts

@@ -7,8 +7,8 @@ import { fieldsPartialTemplate } from '../transpiler/markdown/plain-markdown/fie
 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 { RenderableContent, StringOrLink } from './renderable/types';
-import { isEmptyLine } from '../adapters/type-utils';
+import { CodeBlock, RenderableContent, StringOrLink } from './adapters/types';
+import { isCodeBlock, isEmptyLine, isInlineCode } from './adapters/type-utils';
 import { groupedMembersPartialTemplate } from '../transpiler/markdown/plain-markdown/grouped-members-partial-template';
 
 export type CompilationRequest = {
@@ -32,7 +32,7 @@ export class Template {
 
     Handlebars.registerHelper('link', link);
     Handlebars.registerHelper('code', convertCodeBlock);
-    Handlebars.registerHelper('withLinks', resolveLinksInContent);
+    Handlebars.registerHelper('renderContent', resolveRenderableContent);
     Handlebars.registerHelper('heading', heading);
     Handlebars.registerHelper('inlineCode', inlineCode);
     Handlebars.registerHelper('splitAndCapitalize', splitAndCapitalize);
@@ -73,17 +73,17 @@ const inlineCode = (text: string) => {
   return new Handlebars.SafeString(`\`${text}\``);
 };
 
-const convertCodeBlock = (language: string, lines: string[]): Handlebars.SafeString => {
+const convertCodeBlock = (codeBlock: CodeBlock): Handlebars.SafeString => {
   return new Handlebars.SafeString(
     `
-\`\`\`${language}
-${lines.join('\n')}
+\`\`\`${codeBlock.language}
+${codeBlock.content.join('\n')}
 \`\`\`
   `.trim(),
   );
 };
 
-const resolveLinksInContent = (description?: RenderableContent[]): string => {
+const resolveRenderableContent = (description?: RenderableContent[]): string => {
   if (!description) {
     return '';
   }
@@ -92,8 +92,14 @@ const resolveLinksInContent = (description?: RenderableContent[]): string => {
     if (isEmptyLine(curr)) {
       return acc + '\n\n';
     }
-
-    return acc + link(curr).trim() + ' ';
+    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() + ' ';
+    }
   }
 
   return description.reduce(reduceDescription, '').trim();

package/src/core/templates/reference-guide.ts

@@ -7,7 +7,7 @@ export const referenceGuideTemplate = `
 {{#each this}}
 ### {{link title}}
 
-{{withLinks description}}
+{{{renderContent description}}}
 
 {{/each}}
 {{/each}}

package/src/model/__tests__/manifest.spec.ts

@@ -1,4 +1,4 @@
-import Manifest from '../manifest';
+import Manifest from '../../core/manifest';
 import { EnumMirror } from '@cparra/apex-reflection';
 
 const sampleEnum: EnumMirror = {

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

@@ -1,5 +1,5 @@
 import { MarkdownFile } from '../markdown-file';
-import { FieldMirrorWithInheritance, FieldOrProperty, PropertyMirrorWithInheritance } from '../inheritance';
+import { FieldMirrorWithInheritance, FieldOrProperty, PropertyMirrorWithInheritance } from '../../core/adapters/types';
 
 export function declareField(
   markdownFile: MarkdownFile,

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

@@ -2,7 +2,7 @@ import { ConstructorMirror, DocComment } from '@cparra/apex-reflection';
 import { MarkdownFile } from '../markdown-file';
 import { ParameterMirror } from '@cparra/apex-reflection';
 import { addCustomDocCommentAnnotations, addMermaid } from './doc-comment-annotation-util';
-import { MethodMirrorWithInheritance } from '../inheritance';
+import { MethodMirrorWithInheritance } from '../../core/adapters/types';
 
 export function declareMethod(
   markdownFile: MarkdownFile,

package/src/model/markdown-type-file.ts

@@ -11,8 +11,12 @@ import { WalkerListener } from '../service/walkers/walker';
 import { MarkdownFile } from './markdown-file';
 import { declareType, declareMethod, declareField } from './markdown-generation-util';
 import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
-import { FieldMirrorWithInheritance, MethodMirrorWithInheritance, PropertyMirrorWithInheritance } from './inheritance';
 import { Settings } from '../settings';
+import {
+  FieldMirrorWithInheritance,
+  MethodMirrorWithInheritance,
+  PropertyMirrorWithInheritance
+} from '../core/adapters/types';
 
 interface GroupAware {
   group?: string;

package/src/service/__tests__/apex-file-reader.spec.ts

@@ -15,6 +15,7 @@ describe('File Reader', () => {
       openApiFileName: 'openapi',
       title: 'Classes',
       includeMetadata: false,
+      linkingStrategy: 'root-relative',
     } as SettingsConfig);
   });
 

package/src/service/apex-file-reader.ts

@@ -1,6 +1,6 @@
 import { Settings } from '../settings';
 import { FileSystem } from './file-system';
-import ApexBundle from '../model/apex-bundle';
+import ApexBundle from '../core/apex-bundle';
 
 const APEX_FILE_EXTENSION = '.cls';
 
@@ -17,7 +17,7 @@ export class ApexFileReader {
     const directoryContents = fileSystem.readDirectory(rootPath);
     directoryContents.forEach((currentFilePath) => {
       const currentPath = fileSystem.joinPath(rootPath, currentFilePath);
-      if (this.readRecursively && fileSystem.isDirectory(currentPath)) {
+      if (fileSystem.isDirectory(currentPath)) {
         bundles = bundles.concat(this.processFiles(fileSystem, currentPath));
       }
 
@@ -44,8 +44,4 @@ export class ApexFileReader {
   private static get sourceDirectory() {
     return Settings.getInstance().sourceDirectory;
   }
-
-  private static get readRecursively() {
-    return Settings.getInstance().recursive;
-  }
 }

package/src/service/manifest-factory.ts

@@ -1,7 +1,7 @@
-import Manifest from '../model/manifest';
+import Manifest from '../core/manifest';
 import { TypeParser } from './parser';
 import { ReflectionResult } from '@cparra/apex-reflection';
-import ApexBundle from '../model/apex-bundle';
+import ApexBundle from '../core/apex-bundle';
 
 /**
  * Builds a new Manifest object, sourcing its types from the received TypeParser.

package/src/service/parser.ts

@@ -1,5 +1,5 @@
 import { ClassMirror, InterfaceMirror, ReflectionResult, Type } from '@cparra/apex-reflection';
-import ApexBundle from '../model/apex-bundle';
+import ApexBundle from '../core/apex-bundle';
 import MetadataProcessor from './metadata-processor';
 import { Logger } from '../util/logger';
 

package/src/settings.ts

@@ -1,4 +1,5 @@
 import { GeneratorChoices } from './transpiler/generator-choices';
+import { LinkingStrategy } from './transpiler/processor-type-transpiler';
 
 export type OnBeforeFileWrite = (file: TargetFile) => TargetFile;
 
@@ -23,13 +24,11 @@ export type TargetType = {
 
 export interface SettingsConfig {
   sourceDirectory: string;
-  recursive: boolean;
   scope: string[];
   outputDir: string;
   targetGenerator: GeneratorChoices;
   indexOnly: boolean;
   defaultGroupName: string;
-  sanitizeHtml: boolean;
   openApiTitle?: string;
   title: string;
   namespace?: string;
@@ -40,6 +39,7 @@ export interface SettingsConfig {
   onAfterProcess?: (files: TargetFile[]) => void;
   onBeforeFileWrite?: (file: TargetFile) => TargetFile;
   frontMatterHeader?: (file: TargetType) => string[];
+  linkingStrategy: LinkingStrategy;
 }
 
 export class Settings {
@@ -62,10 +62,6 @@ export class Settings {
     return this.config.sourceDirectory;
   }
 
-  get recursive(): boolean {
-    return this.config.recursive;
-  }
-
   get scope(): string[] {
     return this.config.scope;
   }
@@ -82,10 +78,6 @@ export class Settings {
     return this.config.indexOnly;
   }
 
-  get sanitizeHtml(): boolean {
-    return this.config.sanitizeHtml;
-  }
-
   public getDefaultGroupName(): string {
     return this.config.defaultGroupName;
   }
@@ -144,4 +136,8 @@ export class Settings {
     }
     return [];
   }
+
+  public getLinkingStrategy(): LinkingStrategy {
+    return this.config.linkingStrategy;
+  }
 }

package/src/test-helpers/SettingsBuilder.ts

@@ -8,17 +8,16 @@ export class SettingsBuilder {
   build(): SettingsConfig {
     return {
       sourceDirectory: './',
-      recursive: true,
       scope: [],
       outputDir: './',
       targetGenerator: 'openapi',
       indexOnly: false,
       defaultGroupName: 'Misc',
-      sanitizeHtml: true,
       openApiTitle: 'Apex API',
       openApiFileName: 'openapi',
       title: 'Classes',
       includeMetadata: false,
+      linkingStrategy: 'root-relative',
     };
   }
 }

package/src/transpiler/factory.ts

@@ -2,7 +2,6 @@ import ProcessorTypeTranspiler from './processor-type-transpiler';
 import { GeneratorChoices } from './generator-choices';
 import { JekyllDocsProcessor } from './markdown/jekyll/jekyll-docsProcessor';
 import DocsifyDocsProcessor from './markdown/docsify/docsify-docs-processor';
-import { PlainMarkdownDocsProcessor } from './markdown/plain-markdown/plain-docsProcessor';
 import { OpenApiDocsProcessor } from './openapi/open-api-docs-processor';
 
 export class TypeTranspilerFactory {
@@ -20,12 +19,11 @@ export class TypeTranspilerFactory {
       case 'docsify':
         this.typeTranspilerCache = new DocsifyDocsProcessor();
         return this.typeTranspilerCache;
-      case 'plain-markdown':
-        this.typeTranspilerCache = new PlainMarkdownDocsProcessor();
-        return this.typeTranspilerCache;
       case 'openapi':
         this.typeTranspilerCache = new OpenApiDocsProcessor();
         return this.typeTranspilerCache;
+      case 'plain-markdown':
+        throw Error('Plain Markdown processor is not supported through this factory anymore.');
       default:
         throw Error('Invalid target generator');
     }