@cparra/apexdocs 3.15.0 → 3.16.0-beta.0

package/README.md

@@ -575,6 +575,16 @@ public class MyClass {
 }
 ```
 
+##### **templates**
+
+Allows providing custom templates for generating Markdown documentation, giving you control over the output format. 
+You can define templates for each type of metadata
+supported by the `markdown` command (class, interface, enum, trigger, LWC, custom object, and reference guide) .
+
+For detailed information about creating custom templates, including examples, available helpers, and configuration options, 
+please refer to the [wiki documentation](https://github.com/cesarParra/apexdocs/wiki/5.-Custom-Templates). You can also find a working example in the 
+`examples/markdown-custom-templates` directory.
+
 #### Changelog Hooks
 
 ##### **transformChangeLogPage**

package/dist/cli/generate.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger$1 = require('../logger-Cqxjp5OT.js');
+var logger$1 = require('../logger-Cq4E5XXO.js');
 var cosmiconfig = require('cosmiconfig');
 var yargs = require('yargs');
 var E = require('fp-ts/Either');

package/dist/index.d.ts

@@ -141,6 +141,225 @@ type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 
+// Apex Reflection-based types
+
+
+// Renderable types
+
+type ReferenceGuideReference = {
+  reference: DocPageReference;
+  title: Link;
+  description: RenderableContent[] | null;
+};
+
+type Link = {
+  readonly __type: 'link';
+  title: string;
+  url: string;
+};
+
+type EmptyLine = {
+  __type: 'empty-line';
+};
+
+type StringOrLink = string | Link;
+
+type RenderableContent = StringOrLink | EmptyLine | CodeBlock | InlineCode;
+
+type EnumValue = {
+  value: string;
+  description?: RenderableContent[];
+};
+
+type CustomTag = {
+  name: string;
+  description?: RenderableContent[];
+};
+
+/**
+ * Represents an annotation to a top-level type. For example, @NamespaceAccessible.
+ */
+type Annotation = string;
+
+type CodeBlock = {
+  readonly __type: 'code-block';
+  language: string;
+  content: string[];
+};
+
+type InlineCode = {
+  readonly __type: 'inline-code';
+  content: string;
+};
+
+type RenderableDocumentation = {
+  annotations?: Annotation[];
+  description?: RenderableContent[];
+  customTags?: CustomTag[];
+  example?: RenderableSection<RenderableContent[] | undefined>;
+  group?: string;
+  author?: string;
+  date?: string;
+  sees?: StringOrLink[];
+};
+
+type RenderableType = {
+  namespace?: string;
+  headingLevel: number;
+  heading: string;
+  name: string;
+  meta: {
+    accessModifier: string;
+  };
+  doc: RenderableDocumentation;
+};
+
+type RenderableMethodParameter = {
+  name: string;
+  type: StringOrLink;
+  description?: RenderableContent[];
+};
+
+type TypeSource = {
+  type: StringOrLink;
+  description?: RenderableContent[];
+};
+
+type RenderableConstructor = {
+  headingLevel: number;
+  heading: string;
+  signature: RenderableSection<CodeBlock>;
+  parameters?: RenderableSection<RenderableMethodParameter[] | undefined>;
+  throws?: RenderableSection<TypeSource[] | undefined>;
+  doc: RenderableDocumentation;
+};
+
+type RenderableMethod = {
+  doc: RenderableDocumentation;
+  headingLevel: number;
+  heading: string;
+  signature: RenderableSection<CodeBlock>;
+  parameters: RenderableSection<RenderableMethodParameter[] | undefined>;
+  returnType: RenderableSection<TypeSource>;
+  throws: RenderableSection<TypeSource[] | undefined>;
+  inherited?: boolean;
+};
+
+type RenderableApexField = {
+  headingLevel: number;
+  heading: string;
+  type: RenderableSection<StringOrLink>;
+  accessModifier: string;
+  inherited?: boolean;
+  signature: RenderableSection<CodeBlock>;
+  doc: RenderableDocumentation;
+};
+
+type RenderableSection<T> = {
+  headingLevel: number;
+  heading: string;
+  value: T;
+};
+
+type GroupedMember<T> = RenderableSection<T[]> & { groupDescription: string | undefined };
+
+type RenderableClass = RenderableType & {
+  type: 'class';
+  extends?: StringOrLink[];
+  implements?: StringOrLink[];
+  classModifier?: string;
+  sharingModifier?: string;
+  constructors: RenderableSection<RenderableConstructor[] | GroupedMember<RenderableConstructor>[]> & {
+    isGrouped: boolean;
+  };
+  methods: RenderableSection<RenderableMethod[] | GroupedMember<RenderableMethod>[]> & { isGrouped: boolean };
+  fields: RenderableSection<RenderableApexField[] | GroupedMember<RenderableApexField>[]> & { isGrouped: boolean };
+  properties: RenderableSection<RenderableApexField[] | GroupedMember<RenderableApexField>[]> & { isGrouped: boolean };
+  innerClasses: RenderableSection<RenderableClass[]>;
+  innerEnums: RenderableSection<RenderableEnum[]>;
+  innerInterfaces: RenderableSection<RenderableInterface[]>;
+};
+
+type RenderableInterface = RenderableType & {
+  type: 'interface';
+  extends?: StringOrLink[];
+  methods: RenderableSection<RenderableMethod[]>;
+};
+
+type RenderableEnum = RenderableType & {
+  type: 'enum';
+  values: RenderableSection<EnumValue[]>;
+};
+
+type RenderableTrigger = Omit<RenderableType, 'meta'> & {
+  type: 'trigger';
+  objectName: string;
+  events: string[];
+};
+
+type RenderableLwc = Omit<RenderableType, 'meta'> & {
+  type: 'lwc';
+  exposed: boolean;
+  description: string | undefined;
+  targets: RenderableSection<string[]>;
+  targetConfigs: RenderableSection<TargetConfigRenderable[]>;
+};
+
+type TargetConfigRenderable = {
+  targetName: string;
+  properties: {
+    type: string;
+    required: boolean;
+    description: string | undefined;
+    label: string;
+    name: string;
+  }[];
+};
+
+type RenderableCustomObject = Omit<RenderableType, 'meta'> & {
+  apiName: string;
+  type: 'customobject';
+  hasFields: boolean;
+  hasRecords: boolean;
+  fields: RenderableSection<RenderableCustomField[]>;
+  metadataRecords: RenderableSection<RenderableCustomMetadata[]>;
+  publishBehavior: string | null;
+};
+
+type RenderableCustomField = {
+  headingLevel: number;
+  heading: string;
+  apiName: string;
+  description: RenderableContent[];
+  pickListValues?: RenderableSection<string[]>;
+  type: 'field';
+  fieldType?: string | null;
+  required: boolean;
+  complianceGroup: string | null;
+  securityClassification: string | null;
+  inlineHelpText: string | null;
+};
+
+type RenderableCustomMetadata = {
+  headingLevel: number;
+  heading: string;
+  apiName: string;
+  type: 'metadata';
+  label: string;
+  protected: boolean;
+};
+
+type Renderable = (
+  | RenderableClass
+  | RenderableInterface
+  | RenderableEnum
+  | RenderableCustomObject
+  | RenderableTrigger
+  | RenderableLwc
+) & {
+  filePath: string | undefined;
+};
+
 type Generators = 'markdown' | 'openapi' | 'changelog';
 
 type LinkingStrategy =
@@ -317,6 +536,45 @@ type Skip = {
 
 // CONFIGURABLE HOOKS
 
+/**
+ * Template configuration for customizing markdown output.
+ */
+type TemplateConfig = {
+  class?: string | ((renderable: RenderableClass, helpers: TemplateHelpers) => string);
+  interface?: string | ((renderable: RenderableInterface, helpers: TemplateHelpers) => string);
+  enum?: string | ((renderable: RenderableEnum, helpers: TemplateHelpers) => string);
+  trigger?: string | ((renderable: RenderableTrigger, helpers: TemplateHelpers) => string);
+  lwc?: string | ((renderable: RenderableLwc, helpers: TemplateHelpers) => string);
+  customObject?: string | ((renderable: RenderableCustomObject, helpers: TemplateHelpers) => string);
+  referenceGuide?: string | ((data: ReferenceGuideData, helpers: TemplateHelpers) => string);
+};
+
+/**
+ * Template helpers for consistent rendering.
+ */
+type TemplateHelpers = {
+  link: (source: StringOrLink) => string;
+  code: (codeBlock: CodeBlock) => string;
+  renderContent: (content?: RenderableContent[]) => string;
+  heading: (level: number, text: string) => string;
+  inlineCode: (text: string) => string;
+  eq: (a: unknown, b: unknown) => boolean;
+  add: (a: number, b: number) => number;
+  lookup: (array: unknown[], index: number) => unknown;
+  parseJSON: (jsonString: string) => unknown | null;
+  startsWith: (str: string, prefix: string) => boolean;
+  substring: (str: string, start: number, length?: number) => string;
+  splitAndCapitalize: (text: string) => string;
+};
+
+/**
+ * Data structure passed to reference guide template functions.
+ */
+type ReferenceGuideData = {
+  referenceGuideTitle: string;
+  references: Record<string, ReferenceGuideReference[]>;
+};
+
 /**
  * The configurable hooks that can be used to modify the output of the Markdown generator.
  */
@@ -326,6 +584,7 @@ type MarkdownConfigurableHooks = {
   transformDocs: TransformDocs;
   transformDocPage: TransformDocPage;
   transformReference: TransformReference;
+  templates?: TemplateConfig;
 };
 
 type ConfigurableDocPageReference = Omit<DocPageReference, 'source'>;
@@ -373,6 +632,11 @@ type TransformChangelogPage = (
  */
 declare function skip(): Skip;
 
+/**
+ * Get all template helpers as an object matching TemplateHelpers type.
+ */
+declare const templateHelpers: TemplateHelpers;
+
 type CallableConfig = Partial<UserDefinedConfig> & {
     sourceDir: string;
     targetGenerator: Generators;
@@ -402,5 +666,5 @@ type ConfigurableChangelogConfig = Omit<Partial<UserDefinedChangelogConfig>, 'ta
  */
 declare function defineChangelogConfig(config: ConfigurableChangelogConfig): Partial<UserDefinedChangelogConfig>;
 
-export { defineChangelogConfig, defineMarkdownConfig, defineOpenApiConfig, process, skip };
-export type { ChangeLogPageData, ChangelogConfigurableHooks, ConfigurableChangelogConfig, ConfigurableDocPageData, ConfigurableDocPageReference, ConfigurableMarkdownConfig, ConfigurableOpenApiConfig, DocPageData, DocPageReference, MacroFunction, MacroSourceMetadata, MarkdownConfigurableHooks, ReferenceGuidePageData, Skip, SourceChangelog, TransformChangelogPage, TransformDocPage, TransformDocs, TransformReference, TransformReferenceGuide, Translations, UserTranslations };
+export { defineChangelogConfig, defineMarkdownConfig, defineOpenApiConfig, process, skip, templateHelpers };
+export type { ChangeLogPageData, ChangelogConfigurableHooks, CodeBlock, ConfigurableChangelogConfig, ConfigurableDocPageData, ConfigurableDocPageReference, ConfigurableMarkdownConfig, ConfigurableOpenApiConfig, DocPageData, DocPageReference, GroupedMember, Link, MacroFunction, MacroSourceMetadata, MarkdownConfigurableHooks, ReferenceGuideData, ReferenceGuidePageData, ReferenceGuideReference, Renderable, RenderableApexField, RenderableClass, RenderableConstructor, RenderableContent, RenderableCustomObject, RenderableEnum, RenderableInterface, RenderableLwc, RenderableMethod, RenderableMethodParameter, RenderableSection, RenderableTrigger, Skip, SourceChangelog, StringOrLink, TemplateConfig, TemplateHelpers, TransformChangelogPage, TransformDocPage, TransformDocs, TransformReference, TransformReferenceGuide, Translations, TypeSource, UserTranslations };

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var logger = require('./logger-Cqxjp5OT.js');
+var logger = require('./logger-Cq4E5XXO.js');
 var E = require('fp-ts/Either');
 require('fp-ts/function');
 require('fp-ts/TaskEither');
@@ -142,6 +142,7 @@ function defineChangelogConfig(config) {
 }
 
 exports.skip = logger.skip;
+exports.templateHelpers = logger.templateHelpers;
 exports.defineChangelogConfig = defineChangelogConfig;
 exports.defineMarkdownConfig = defineMarkdownConfig;
 exports.defineOpenApiConfig = defineOpenApiConfig;

package/dist/{logger-Cqxjp5OT.js → logger-Cq4E5XXO.js}

@@ -1674,6 +1674,102 @@ const interfaceMarkdownTemplate = `
 {{/if}}
 `.trim();
 
+function link(source) {
+  if (typeof source === "string") {
+    return source;
+  } else {
+    return `[${source.title}](${source.url})`;
+  }
+}
+function code(codeBlock) {
+  return `
+\`\`\`${codeBlock.language}
+${codeBlock.content.join("\n")}
+\`\`\`
+`.trim();
+}
+function inlineCodeToString(inlineCode2) {
+  return `\`${inlineCode2.content}\``;
+}
+function renderContent(content, escapeFunction) {
+  if (!content || content.length === 0) {
+    return "";
+  }
+  function reduceDescription(acc, curr) {
+    if (isEmptyLine(curr)) {
+      return acc + "\n";
+    }
+    if (isCodeBlock(curr)) {
+      return acc + code(curr) + "\n";
+    }
+    if (isInlineCode(curr)) {
+      return acc + inlineCodeToString(curr) + " ";
+    } else {
+      const linkResult = link(curr);
+      const escapedLink = escapeFunction ? escapeFunction(linkResult) : linkResult;
+      return acc + escapedLink.trim() + " ";
+    }
+  }
+  return content.reduce(reduceDescription, "").trim();
+}
+function heading(level, text) {
+  if (level < 1 || level > 6) {
+    throw new Error(`Heading level must be between 1 and 6, got ${level}`);
+  }
+  return `${"#".repeat(level)} ${text}`;
+}
+function inlineCode(text) {
+  return `\`${text}\``;
+}
+function eq(a, b) {
+  return a === b;
+}
+function add(a, b) {
+  return a + b;
+}
+function lookup(array, index) {
+  return array[index];
+}
+function parseJSON(jsonString) {
+  try {
+    return JSON.parse(jsonString);
+  } catch (e) {
+    return null;
+  }
+}
+function startsWith(str, prefix) {
+  return str.startsWith(prefix);
+}
+function substring(str, start, length) {
+  if (length !== void 0) {
+    return str.substring(start, start + length);
+  }
+  return str.substring(start);
+}
+function splitAndCapitalize(text) {
+  const words = text.split(/[-_]+/);
+  const capitalizedWords = [];
+  for (const word of words) {
+    capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
+  }
+  return capitalizedWords.join(" ");
+}
+const templateHelpers = {
+  link,
+  code,
+  renderContent: (content) => renderContent(content),
+  // Wrap to match TemplateHelpers signature
+  heading,
+  inlineCode,
+  eq,
+  add,
+  lookup,
+  parseJSON,
+  startsWith,
+  substring,
+  splitAndCapitalize
+};
+
 class Template {
   constructor() {
     Handlebars.registerPartial("typeDocumentation", typeDocPartial);
@@ -1685,11 +1781,19 @@ class Template {
     Handlebars.registerPartial("classTemplate", classMarkdownTemplate);
     Handlebars.registerPartial("enumTemplate", enumMarkdownTemplate);
     Handlebars.registerPartial("interfaceTemplate", interfaceMarkdownTemplate);
-    Handlebars.registerHelper("link", link);
-    Handlebars.registerHelper("code", convertCodeBlock);
-    Handlebars.registerHelper("renderContent", resolveRenderableContent);
+    Handlebars.registerHelper("link", (source) => {
+      return new Handlebars.SafeString(link(source));
+    });
+    Handlebars.registerHelper("code", (codeBlock) => {
+      return new Handlebars.SafeString(code(codeBlock));
+    });
+    Handlebars.registerHelper("renderContent", (content) => {
+      return renderContent(content, Handlebars.escapeExpression);
+    });
     Handlebars.registerHelper("heading", heading);
-    Handlebars.registerHelper("inlineCode", inlineCode);
+    Handlebars.registerHelper("inlineCode", (text) => {
+      return new Handlebars.SafeString(inlineCode(text));
+    });
     Handlebars.registerHelper("splitAndCapitalize", splitAndCapitalize);
     Handlebars.registerHelper("eq", eq);
     Handlebars.registerHelper("add", add);
@@ -1709,80 +1813,6 @@ class Template {
     return compiled(request.source).trim().replace(/\n{3,}/g, "\n\n");
   }
 }
-const splitAndCapitalize = (text) => {
-  const words = text.split(/[-_]+/);
-  const capitalizedWords = [];
-  for (const word of words) {
-    capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
-  }
-  return capitalizedWords.join(" ");
-};
-const heading = (level, text) => {
-  return `${"#".repeat(level)} ${text}`;
-};
-const inlineCode = (text) => {
-  return new Handlebars.SafeString(`\`${text}\``);
-};
-const eq = (a, b) => {
-  return a === b;
-};
-const add = (a, b) => {
-  return a + b;
-};
-const lookup = (array, index) => {
-  return array[index];
-};
-const parseJSON = (jsonString) => {
-  try {
-    return JSON.parse(jsonString);
-  } catch (e) {
-    return null;
-  }
-};
-const startsWith = (str, prefix) => {
-  return str.startsWith(prefix);
-};
-const substring = (str, start, length) => {
-  if (length !== void 0) {
-    return str.substring(start, start + length);
-  }
-  return str.substring(start);
-};
-const convertCodeBlock = (codeBlock) => {
-  return new Handlebars.SafeString(
-    `
-\`\`\`${codeBlock.language}
-${codeBlock.content.join("\n")}
-\`\`\`
-  `.trim()
-  );
-};
-const resolveRenderableContent = (description) => {
-  if (!description) {
-    return "";
-  }
-  function reduceDescription(acc, curr) {
-    if (isEmptyLine(curr)) {
-      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() + " ";
-    }
-  }
-  return description.reduce(reduceDescription, "").trim();
-};
-const link = (source) => {
-  if (typeof source === "string") {
-    return source;
-  } else {
-    return `[${source.title}](${source.url})`;
-  }
-};
 
 var __defProp$k = Object.defineProperty;
 var __defProps$j = Object.defineProperties;
@@ -1992,23 +2022,43 @@ var __spreadValues$j = (a, b) => {
   return a;
 };
 var __spreadProps$i = (a, b) => __defProps$i(a, __getOwnPropDescs$i(b));
-const convertToDocumentationBundle = (referenceGuideTitle, referenceGuideTemplate, translations, { referencesByGroup, renderables }) => ({
+const convertToDocumentationBundle = (referenceGuideTitle, referenceGuideTemplate, translations, { referencesByGroup, renderables }, templates) => ({
   referenceGuide: {
     frontmatter: null,
-    content: referencesToReferenceGuideContent(referenceGuideTitle, referencesByGroup, referenceGuideTemplate),
+    content: referencesToReferenceGuideContent(
+      referenceGuideTitle,
+      referencesByGroup,
+      referenceGuideTemplate,
+      templates
+    ),
     outputDocPath: "index.md"
   },
   docs: renderables.map(
-    (renderable) => renderableToPageData(Object.values(referencesByGroup).flat(), renderable, translations)
+    (renderable) => renderableToPageData(Object.values(referencesByGroup).flat(), renderable, translations, templates)
   )
 });
-function referencesToReferenceGuideContent(referenceGuideTitle, references, template) {
+function referencesToReferenceGuideContent(referenceGuideTitle, references, template, templates) {
   function alphabetizeReferences(references2) {
     return Object.keys(references2).sort((a, b) => a.localeCompare(b)).reduce((acc, key) => {
       acc[key] = references2[key].sort((a, b) => a.title.toString().localeCompare(b.title.toString()));
       return acc;
     }, {});
   }
+  const referenceGuideTemplateConfig = templates == null ? void 0 : templates.referenceGuide;
+  if (referenceGuideTemplateConfig) {
+    const alphabetizedReferences = alphabetizeReferences(references);
+    const referenceGuideData = {
+      referenceGuideTitle,
+      references: alphabetizedReferences
+    };
+    const templateRequest = handleTemplateConfig(referenceGuideTemplateConfig, referenceGuideData, templateHelpers);
+    if ("template" in templateRequest) {
+      return compile$1({
+        template: templateRequest.template,
+        source: templateRequest.source
+      });
+    }
+  }
   return _function.pipe(
     references,
     alphabetizeReferences,
@@ -2018,7 +2068,7 @@ function referencesToReferenceGuideContent(referenceGuideTitle, references, temp
     })
   );
 }
-function renderableToPageData(referenceGuideReference, renderable, translations) {
+function renderableToPageData(referenceGuideReference, renderable, translations, templates) {
   function buildDocOutput(renderable2, docContents) {
     var _a;
     const reference = referenceGuideReference.find(
@@ -2039,12 +2089,16 @@ function renderableToPageData(referenceGuideReference, renderable, translations)
   }
   return _function.pipe(
     renderable,
-    (r) => resolveTemplate(r, translations),
-    compile$1,
+    (r) => resolveTemplate(r, translations, templates),
+    (templateOrRequest) => compileTemplate(templateOrRequest),
     (docContents) => buildDocOutput(renderable, docContents)
   );
 }
-function resolveTemplate(renderable, translations) {
+function resolveTemplate(renderable, translations, templates) {
+  const customTemplate = getCustomTemplate(renderable, templates);
+  if (customTemplate) {
+    return customTemplate;
+  }
   function getTemplate(renderable2) {
     switch (renderable2.type) {
       case "enum":
@@ -2068,9 +2122,67 @@ function resolveTemplate(renderable, translations) {
     })
   };
 }
+function getCustomTemplate(renderable, templates) {
+  if (!templates) {
+    return null;
+  }
+  switch (renderable.type) {
+    case "enum":
+      if (templates.enum) {
+        return handleTemplateConfig(templates.enum, renderable, templateHelpers);
+      }
+      break;
+    case "interface":
+      if (templates.interface) {
+        return handleTemplateConfig(templates.interface, renderable, templateHelpers);
+      }
+      break;
+    case "class":
+      if (templates.class) {
+        return handleTemplateConfig(templates.class, renderable, templateHelpers);
+      }
+      break;
+    case "customobject":
+      if (templates.customObject) {
+        return handleTemplateConfig(templates.customObject, renderable, templateHelpers);
+      }
+      break;
+    case "trigger":
+      if (templates.trigger) {
+        return handleTemplateConfig(templates.trigger, renderable, templateHelpers);
+      }
+      break;
+    case "lwc":
+      if (templates.lwc) {
+        return handleTemplateConfig(templates.lwc, renderable, templateHelpers);
+      }
+      break;
+  }
+  return null;
+}
+function handleTemplateConfig(templateConfig, renderable, helpers) {
+  if (typeof templateConfig === "string") {
+    return {
+      template: templateConfig,
+      source: renderable
+    };
+  } else {
+    const result = templateConfig(renderable, helpers);
+    return {
+      template: "{{{content}}}",
+      source: { content: result }
+    };
+  }
+}
 function compile$1(request) {
   return Template.getInstance().compile(request);
 }
+function compileTemplate(templateOrRequest) {
+  if ("template" in templateOrRequest) {
+    return Template.getInstance().compile(templateOrRequest);
+  }
+  throw new Error("Invalid template request");
+}
 
 var __defProp$i = Object.defineProperty;
 var __defProps$h = Object.defineProperties;
@@ -3080,11 +3192,12 @@ function generateDocs(unparsedBundles, config) {
   const translations = mergeTranslations({ markdown: config.translations });
   const convertToReferences = apply(parsedFilesToReferenceGuide, config);
   const convertToRenderableBundle = apply(parsedFilesToRenderableBundle, config);
-  const convertToDocumentationBundleForTemplate = apply(
-    convertToDocumentationBundle,
+  const convertToDocumentationBundleForTemplate = (bundle, templates) => convertToDocumentationBundle(
     config.referenceGuideTitle,
     config.referenceGuideTemplate,
-    translations
+    translations,
+    bundle,
+    templates
   );
   const sort = apply(sortTypesAndMembers, config.sortAlphabetically);
   function filterOutCustomFieldsAndMetadata(parsedFiles) {
@@ -3133,7 +3246,7 @@ function generateDocs(unparsedBundles, config) {
     TE__namespace.map(
       ({ parsedFiles, references }) => convertToRenderableBundle(filterOutCustomFieldsAndMetadata(parsedFiles), references, translations)
     ),
-    TE__namespace.map(convertToDocumentationBundleForTemplate),
+    TE__namespace.map((bundle) => convertToDocumentationBundleForTemplate(bundle, config.templates)),
     TE__namespace.flatMap(transformDocumentationBundleHook(config)),
     TE__namespace.map(postHookCompile$1)
   );
@@ -5660,4 +5773,5 @@ exports.changeLogDefaults = changeLogDefaults;
 exports.markdownDefaults = markdownDefaults;
 exports.openApiDefaults = openApiDefaults;
 exports.skip = skip;
+exports.templateHelpers = templateHelpers;
 exports.validateSourceDirectoryConfig = validateSourceDirectoryConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.15.0",
+  "version": "3.16.0-beta.0",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",