@cparra/apexdocs 3.0.0 → 3.1.0

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

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

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

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

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

@@ -1,23 +0,0 @@
-import { ClassMirror, Type } from '@cparra/apex-reflection';
-import { pipe } from 'fp-ts/function';
-import * as O from 'fp-ts/Option';
-
-export function createInheritanceChain(repository: Type[], classMirror: ClassMirror): string[] {
-  return pipe(
-    O.fromNullable(classMirror.extended_class),
-    O.match(
-      () => [],
-      (extendedClassName) => inheritanceChainFromParentClassName(repository, extendedClassName),
-    ),
-  );
-}
-
-function inheritanceChainFromParentClassName(repository: Type[], className: string): string[] {
-  return pipe(
-    O.fromNullable(repository.find((type) => type.name.toLowerCase() === className.toLowerCase())),
-    O.match(
-      () => [className],
-      (extendedClass: Type) => [className, ...createInheritanceChain(repository, extendedClass as ClassMirror)],
-    ),
-  );
-}

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

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

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

@@ -1,123 +0,0 @@
-import { ParsedFile, UnparsedSourceFile } from '../../shared/types';
-import * as TE from 'fp-ts/TaskEither';
-import * as E from 'fp-ts/Either';
-import * as T from 'fp-ts/Task';
-import * as A from 'fp-ts/lib/Array';
-import { Annotation, reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
-import { pipe } from 'fp-ts/function';
-import * as O from 'fp-ts/Option';
-import { parseApexMetadata } from '../../parse-apex-metadata';
-import { ParsingError } from '@cparra/apex-reflection';
-import { apply } from '#utils/fp';
-import { Semigroup } from 'fp-ts/Semigroup';
-
-export class ReflectionErrors {
-  readonly _tag = 'ReflectionErrors';
-
-  constructor(public errors: ReflectionError[]) {}
-}
-
-export class ReflectionError {
-  constructor(
-    public file: string,
-    public message: string,
-  ) {}
-}
-
-async function reflectAsync(rawSource: string): Promise<Type> {
-  return new Promise((resolve, reject) => {
-    const result = mirrorReflection(rawSource);
-    if (result.typeMirror) {
-      return resolve(result.typeMirror);
-    } else if (result.error) {
-      return reject(result.error);
-    } else {
-      return reject(new Error('Unknown error'));
-    }
-  });
-}
-
-export function reflectBundles(apexBundles: UnparsedSourceFile[]) {
-  const semiGroupReflectionError: Semigroup<ReflectionErrors> = {
-    concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors]),
-  };
-  const Ap = TE.getApplicativeTaskValidation(T.ApplyPar, semiGroupReflectionError);
-
-  return pipe(apexBundles, A.traverse(Ap)(reflectBundle));
-}
-
-function reflectBundle(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, ParsedFile> {
-  const convertToParsedFile: (typeMirror: Type) => ParsedFile = apply(toParsedFile, apexBundle.filePath);
-  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
-
-  return pipe(apexBundle, reflectAsTask, TE.map(convertToParsedFile), TE.flatMap(withMetadata));
-}
-
-function reflectAsTask(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, Type> {
-  return TE.tryCatch(
-    () => reflectAsync(apexBundle.content),
-    (error) =>
-      new ReflectionErrors([new ReflectionError(apexBundle.filePath, (error as ParsingError | Error).message)]),
-  );
-}
-
-function toParsedFile(filePath: string, typeMirror: Type): ParsedFile {
-  return {
-    source: {
-      filePath: filePath,
-      name: typeMirror.name,
-      type: typeMirror.type_name,
-    },
-    type: typeMirror,
-  };
-}
-
-function addMetadata(
-  rawMetadataContent: string | null,
-  parsedFile: ParsedFile,
-): TE.TaskEither<ReflectionErrors, ParsedFile> {
-  return TE.fromEither(
-    pipe(
-      parsedFile.type,
-      (type) => addFileMetadataToTypeAnnotation(type, rawMetadataContent),
-      E.map((type) => ({ ...parsedFile, type })),
-      E.mapLeft((error) => errorToReflectionErrors(error, parsedFile.source.filePath)),
-    ),
-  );
-}
-
-function errorToReflectionErrors(error: Error, filePath: string): ReflectionErrors {
-  return new ReflectionErrors([new ReflectionError(filePath, error.message)]);
-}
-
-function addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): E.Either<Error, Type> {
-  const concatAnnotationToType = apply(concatAnnotations, type);
-
-  return pipe(
-    O.fromNullable(metadata),
-    O.map(concatAnnotationToType),
-    O.getOrElse(() => E.right(type)),
-  );
-}
-
-function concatAnnotations(type: Type, metadataInput: string): E.Either<Error, Type> {
-  return pipe(
-    metadataInput,
-    parseApexMetadata,
-    E.map((metadataMap) => ({
-      ...type,
-      annotations: [...type.annotations, ...mapToAnnotations(metadataMap)],
-    })),
-  );
-}
-
-function mapToAnnotations(metadata: Map<string, string>): Annotation[] {
-  return Array.from(metadata.entries()).map(([key, value]) => {
-    const declaration = `${key}: ${value}`;
-    return {
-      name: declaration,
-      type: declaration,
-      rawDeclaration: declaration,
-    };
-  });
-}

package/src/core/markdown/reflection/remove-excluded-tags.ts

@@ -1,168 +0,0 @@
-import * as O from 'fp-ts/Option';
-import { match } from 'fp-ts/boolean';
-import { ParsedFile } from '../../shared/types';
-import { ClassMirror, DocComment, InterfaceMirror, Type } from '@cparra/apex-reflection';
-import { pipe } from 'fp-ts/function';
-import { apply } from '#utils/fp';
-
-type AppliedRemoveTagFn = (tagName: string, removeFn: RemoveTagFn) => DocComment;
-type RemoveTagFn = (docComment: DocComment) => DocComment;
-type Documentable = { docComment?: DocComment };
-
-export const removeExcludedTags = (excludedTags: string[], parsedFiles: ParsedFile[]): ParsedFile[] => {
-  return parsedFiles.map((parsedFile) => {
-    return {
-      ...parsedFile,
-      type: removeExcludedTagsFromType(excludedTags, parsedFile.type),
-    };
-  });
-};
-
-const removeExcludedTagsFromType = <T extends Type>(excludedTags: string[], type: T): T => {
-  return {
-    ...handleType(excludedTags, type),
-    docComment: removeExcludedTagsFromDocComment(excludedTags, type.docComment),
-  } as T;
-};
-
-const handleType = (excludedTags: string[], type: Type): Type => {
-  switch (type.type_name) {
-    case 'class':
-      return handleClass(excludedTags, type as ClassMirror);
-    case 'interface':
-      return handleInterface(excludedTags, type as InterfaceMirror);
-    case 'enum':
-      return type;
-  }
-};
-
-const handleClass = (excludedTags: string[], classMirror: ClassMirror): ClassMirror => {
-  return {
-    ...classMirror,
-    methods: classMirror.methods.map((method) => removeExcludedTagsFromDocumentable(excludedTags, method)),
-    properties: classMirror.properties.map((property) => removeExcludedTagsFromDocumentable(excludedTags, property)),
-    fields: classMirror.fields.map((field) => removeExcludedTagsFromDocumentable(excludedTags, field)),
-    constructors: classMirror.constructors.map((constructor) =>
-      removeExcludedTagsFromDocumentable(excludedTags, constructor),
-    ),
-    enums: classMirror.enums.map((enumType) => removeExcludedTagsFromType(excludedTags, enumType)),
-    interfaces: classMirror.interfaces.map((interfaceType) => removeExcludedTagsFromType(excludedTags, interfaceType)),
-    classes: classMirror.classes.map((innerClass) => removeExcludedTagsFromType(excludedTags, innerClass)),
-  };
-};
-
-const handleInterface = (excludedTags: string[], interfaceMirror: InterfaceMirror): InterfaceMirror => {
-  return {
-    ...interfaceMirror,
-    methods: interfaceMirror.methods.map((method) => removeExcludedTagsFromDocumentable(excludedTags, method)),
-  };
-};
-
-const removeExcludedTagsFromDocumentable = <T extends Documentable>(excludedTags: string[], documentable: T): T => {
-  return {
-    ...documentable,
-    docComment: removeExcludedTagsFromDocComment(excludedTags, documentable.docComment),
-  };
-};
-
-const removeExcludedTagsFromDocComment = (
-  excludedTags: string[],
-  docComment: DocComment | undefined,
-): DocComment | undefined => {
-  const removerFn = apply(remove, excludedTags);
-
-  return pipe(
-    O.fromNullable(docComment),
-    O.map((docComment) => removeExcludedTagsFromAnnotations(excludedTags, docComment)),
-    O.map((docComment) => removeExampleTag(apply(removerFn, docComment))),
-    O.map((docComment) => removeParamTags(apply(removerFn, docComment))),
-    O.map((docComment) => removeReturnTag(apply(removerFn, docComment))),
-    O.map((docComment) => removeThrowsTag(apply(removerFn, docComment))),
-    O.map((docComment) => removeExceptionTag(apply(removerFn, docComment))),
-    O.map((docComment) => removeDescription(apply(removerFn, docComment))),
-    O.fold(
-      () => undefined,
-      (updatedDocComment) => updatedDocComment,
-    ),
-  );
-};
-
-const removeExcludedTagsFromAnnotations = (excludedTags: string[], docComment: DocComment): DocComment => {
-  return pipe(
-    O.some(docComment.annotations),
-    O.map((annotations) => annotations.filter((annotation) => !includesIgnoreCase(excludedTags, annotation.name))),
-    O.fold(
-      () => docComment,
-      (filteredAnnotations) => ({
-        ...docComment,
-        annotations: filteredAnnotations,
-      }),
-    ),
-  );
-};
-
-const removeExampleTag = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('example', (docComment) => {
-    return {
-      ...docComment,
-      exampleAnnotation: null,
-    };
-  });
-};
-
-const removeParamTags = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('param', (docComment) => {
-    return {
-      ...docComment,
-      paramAnnotations: [],
-    };
-  });
-};
-
-const removeReturnTag = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('return', (docComment) => {
-    return {
-      ...docComment,
-      returnAnnotation: null,
-    };
-  });
-};
-
-const removeThrowsTag = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('throws', (docComment) => {
-    return {
-      ...docComment,
-      throwsAnnotations: [],
-    };
-  });
-};
-
-const removeExceptionTag = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('exception', (docComment) => {
-    return {
-      ...docComment,
-      throwsAnnotations: [],
-    };
-  });
-};
-
-const removeDescription = (remover: AppliedRemoveTagFn): DocComment => {
-  return remover('description', (docComment) => {
-    return {
-      ...docComment,
-      description: '',
-      descriptionLines: [],
-    };
-  });
-};
-
-const remove = (excludedTags: string[], docComment: DocComment, tagName: string, removeFn: RemoveTagFn): DocComment => {
-  return match(
-    () => docComment,
-    () => removeFn(docComment!),
-  )(includesIgnoreCase(excludedTags, tagName) && !!docComment);
-};
-
-const includesIgnoreCase = (excluded: string[], value: string): boolean => {
-  return excluded.some((element) => element.toLowerCase() === value.toLowerCase());
-};

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

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

package/src/core/markdown/templates/class-template.ts

@@ -1,75 +0,0 @@
-export const classMarkdownTemplate = `
-{{ heading headingLevel heading }}
-{{#if classModifier}}
-\`{{classModifier}}\`
-{{/if}}
-
-{{> typeDocumentation}}
-
-{{#if extends.length}}
-**Inheritance**
-
-{{#each extends}}{{link this}}{{#unless @last}} < {{/unless}}{{/each}}
-{{/if}}
-
-{{#if implements}}
-**Implements**
-
-{{#each implements}}
-{{link this}}{{#unless @last}}, {{/unless}}
-{{/each}}
-{{/if}}
-
-{{#if fields.value}}
-{{#if fields.isGrouped}}
-{{> groupedMembersPartialTemplate fields subTemplate="fieldsPartialTemplate"}}
-{{else}}
-{{> fieldsPartialTemplate fields}}
-{{/if}}
-{{/if}}
-
-{{#if properties.value}}
-{{#if properties.isGrouped}}
-{{> groupedMembersPartialTemplate properties subTemplate="fieldsPartialTemplate"}}
-{{else}}
-{{> fieldsPartialTemplate properties}}
-{{/if}}
-{{/if}}
-
-{{#if constructors.value}}
-{{#if constructors.isGrouped}}
-{{> groupedMembersPartialTemplate constructors subTemplate="constructorsPartialTemplate"}}
-{{else}}
-{{> constructorsPartialTemplate constructors}}
-{{/if}}
-{{/if}}
-
-{{#if methods.value}}
-{{#if methods.isGrouped}}
-{{> groupedMembersPartialTemplate methods subTemplate="methodsPartialTemplate"}}
-{{else}}
-{{> methodsPartialTemplate methods}}
-{{/if}}
-{{/if}}
-
-{{#if innerClasses.value}}
-{{ heading innerClasses.headingLevel innerClasses.heading }}
-{{#each innerClasses.value}}
-{{> classTemplate this}}
-{{/each}}
-{{/if}}
-
-{{#if innerEnums.value}}
-{{ heading innerEnums.headingLevel innerEnums.heading }}
-{{#each innerEnums.value}}
-{{> enumTemplate this}}
-{{/each}}
-{{/if}}
-
-{{#if innerInterfaces.value}}
-{{ heading innerInterfaces.headingLevel innerInterfaces.heading }}
-{{#each innerInterfaces.value}}
-{{> interfaceTemplate this}}
-{{/each}}
-{{/if}}
-`.trim();

package/src/core/markdown/templates/constructors-partial-template.ts

@@ -1,32 +0,0 @@
-export const constructorsPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{{ heading headingLevel (inlineCode heading) }}}
-
-{{#> documentablePartialTemplate}}
-
-{{ heading signature.headingLevel signature.heading }}
-{{ code signature.value }}
-
-{{#if parameters.value}}
-{{ heading parameters.headingLevel parameters.heading }}
-| Name | Type | Description |
-|------|------|-------------|
-{{#each parameters.value}}
-| {{name}} | {{link type}} | {{description}} |
-{{/each}}
-{{/if}}
-
-{{#if throws.value}}
-{{ heading throws.headingLevel throws.heading }}
-{{#each throws.value}}
-{{link this.type}}: {{this.description}}
-
-{{/each}}
-{{/if}}
-{{/documentablePartialTemplate}}
-
-{{#unless @last}}---{{/unless}}
-
-{{/each}}
-`.trim();

package/src/core/markdown/templates/documentable-partial-template.ts

@@ -1,26 +0,0 @@
-export const documentablePartialTemplate = `
-{{#each doc.annotations}}
-\`{{this}}\`
-{{/each}}
-
-{{{renderContent doc.description}}}
-
-{{#each doc.customTags}}
-**{{splitAndCapitalize name}}** 
-
-{{{renderContent description}}}
-
-{{/each}}
-
-{{> @partial-block}}
-
-{{#if doc.mermaid.value}}
-{{ heading doc.mermaid.headingLevel doc.mermaid.heading }}
-{{code doc.mermaid.value}}
-{{/if}}
-
-{{#if doc.example.value}}
-{{ heading doc.example.headingLevel doc.example.heading }}
-{{{renderContent doc.example.value}}}
-{{/if}}
-`.trim();

package/src/core/markdown/templates/enum-template.ts

@@ -1,12 +0,0 @@
-export const enumMarkdownTemplate = `
-{{ heading headingLevel heading }}
-
-{{> typeDocumentation }}
-
-{{ heading values.headingLevel values.heading }}
-| Value | Description |
-|-------|-------------|
-{{#each values.value}}
-| {{value}} | {{description}} |
-{{/each}}
-`.trim();

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

@@ -1,23 +0,0 @@
-export const fieldsPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{{ heading headingLevel (inlineCode heading) }}}
-
-{{#if inherited}}
-*Inherited*
-{{/if}}
-
-{{#> documentablePartialTemplate }}
-
-{{ heading signature.headingLevel signature.heading }}
-{{ code signature.value }}
-
-{{ heading type.headingLevel type.heading }}
-{{link type.value}}
-
-{{/documentablePartialTemplate}}
-
-{{#unless @last}}---{{/unless}}
-
-{{/each}}
-`.trim();