@cparra/apexdocs 3.0.0-alpha.1 → 3.0.0-alpha.10

package/src/core/markdown/adapters/generate-link.ts

@@ -0,0 +1,82 @@
+import { StringOrLink } from './types';
+import path from 'path';
+import { LinkingStrategy } from '../../shared/types';
+
+export type LinkingStrategyFn = (
+  references: Record<string, { referencePath: string; displayName: string } | undefined>,
+  from: string,
+  referenceName: string,
+) => StringOrLink;
+
+export const generateLink = (strategy: LinkingStrategy): LinkingStrategyFn => {
+  switch (strategy) {
+    case 'relative':
+      return generateRelativeLink;
+    case 'no-link':
+      return generateNoLink;
+    case 'none':
+      return returnReferenceAsIs;
+  }
+};
+
+const generateRelativeLink = (
+  references: Record<string, { referencePath: string; displayName: string } | undefined>,
+  from: string, // The name of the file for which the reference is being generated
+  referenceName: string,
+): StringOrLink => {
+  function getRelativePath(fromPath: string, toPath: string) {
+    return path.relative(path.parse(path.join('/', fromPath)).dir, path.join('/', toPath));
+  }
+
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+  // When linking from the base path (e.g. the reference guide/index page), the reference path is the same as the output
+  // path.
+  if (referenceTo && from === '__base__') {
+    return {
+      __type: 'link',
+      title: referenceTo.displayName,
+      url: getRelativePath('', referenceTo.referencePath),
+    };
+  }
+
+  const referenceFrom = references[from];
+
+  if (!referenceFrom) {
+    return referenceTo.displayName;
+  }
+
+  return {
+    __type: 'link',
+    title: referenceTo.displayName,
+    url: getRelativePath(referenceFrom.referencePath, referenceTo.referencePath),
+  };
+};
+
+const generateNoLink = (
+  references: Record<string, { referencePath: string; displayName: string } | undefined>,
+  _from: string,
+  referenceName: string,
+): StringOrLink => {
+  const referenceTo = references[referenceName];
+  return referenceTo ? referenceTo.displayName : referenceName;
+};
+
+const returnReferenceAsIs = (
+  references: Record<string, { referencePath: string; displayName: string } | undefined>,
+  _from: string,
+  referenceName: string,
+): StringOrLink => {
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+
+  return {
+    __type: 'link',
+    title: referenceTo.displayName,
+    url: referenceTo.referencePath,
+  };
+};

package/src/core/markdown/adapters/reference-guide.ts

@@ -13,10 +13,12 @@ export function parsedFilesToReferenceGuide(
 }
 
 function parsedFileToDocPageReference(config: MarkdownGeneratorConfig, parsedFile: ParsedFile): DocPageReference {
+  const path = `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`;
   return {
     source: parsedFile.source,
     displayName: parsedFile.type.name,
-    pathFromRoot: `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`,
+    outputDocPath: path,
+    referencePath: path,
   };
 }
 

package/src/core/markdown/adapters/renderable-bundle.ts

@@ -1,29 +1,29 @@
 import { DocPageReference, ParsedFile } from '../../shared/types';
-import { Link, ReferenceGuideReference, Renderable, RenderableBundle, StringOrLink } from './types';
+import { Link, ReferenceGuideReference, Renderable, RenderableBundle } from './types';
 import { typeToRenderable } from './apex-types';
 import { adaptDescribable } from './documentables';
 import { MarkdownGeneratorConfig } from '../generate-docs';
 import { apply } from '#utils/fp';
 import { Type } from '@cparra/apex-reflection';
-import * as path from 'path';
+import { generateLink } from './generate-link';
 
 export function parsedFilesToRenderableBundle(
   config: MarkdownGeneratorConfig,
   parsedFiles: ParsedFile[],
   references: Record<string, DocPageReference>,
 ): RenderableBundle {
-  const referenceFinder = apply(linkGenerator, references, config.documentationRootDir);
+  const referenceFinder = apply(generateLink(config.linkingStrategy), references);
 
   function toReferenceGuide(parsedFiles: ParsedFile[]): Record<string, ReferenceGuideReference[]> {
     return parsedFiles.reduce<Record<string, ReferenceGuideReference[]>>(
-      addToReferenceGuide(referenceFinder, config, references),
+      addToReferenceGuide(apply(referenceFinder, '__base__'), config, references),
       {},
     );
   }
 
   function toRenderables(parsedFiles: ParsedFile[]): Renderable[] {
     return parsedFiles.reduce<Renderable[]>((acc, parsedFile) => {
-      const renderable = typeToRenderable(parsedFile, referenceFinder, config);
+      const renderable = typeToRenderable(parsedFile, apply(referenceFinder, parsedFile.source.name), config);
       acc.push(renderable);
       return acc;
     }, []);
@@ -55,23 +55,6 @@ function addToReferenceGuide(
   };
 }
 
-const linkGenerator = (
-  references: Record<string, DocPageReference>,
-  documentationRootDir: string,
-  referenceName: string,
-): StringOrLink => {
-  const reference: DocPageReference | undefined = references[referenceName];
-
-  return reference
-    ? // Starting the path with a "/" will ensure the link will always be relative to the root of the site.
-      {
-        __type: 'link',
-        title: reference.displayName,
-        url: path.join('/', documentationRootDir, reference.pathFromRoot),
-      }
-    : referenceName;
-};
-
 function getTypeGroup(type: Type, config: MarkdownGeneratorConfig): string {
   const groupAnnotation = type.docComment?.annotations.find((annotation) => annotation.name.toLowerCase() === 'group');
   return groupAnnotation?.body ?? config.defaultGroupName;

package/src/core/markdown/adapters/renderable-to-page-data.ts

@@ -14,7 +14,7 @@ export const convertToDocumentationBundle = (
   referenceGuide: {
     frontmatter: null,
     content: referencesToReferenceGuideContent(referencesByGroup, referenceGuideTemplate),
-    filePath: 'index.md',
+    outputDocPath: 'index.md',
   },
   docs: renderables.map((renderable: Renderable) =>
     renderableToPageData(Object.values(referencesByGroup).flat(), renderable),
@@ -56,7 +56,7 @@ function renderableToPageData(referenceGuideReference: ReferenceGuideReference[]
         name: renderable.name,
         type: renderable.type,
       },
-      filePath: reference!.reference.pathFromRoot,
+      outputDocPath: reference!.reference.outputDocPath,
       frontmatter: null,
       content: docContents,
       group: renderable.doc.group ?? defaults.defaultGroupName,

package/src/core/markdown/generate-docs.ts

@@ -1,5 +1,4 @@
 import { pipe } from 'fp-ts/function';
-import * as E from 'fp-ts/Either';
 import * as TE from 'fp-ts/TaskEither';
 import yaml from 'js-yaml';
 
@@ -20,8 +19,7 @@ import {
   ParsedFile,
 } from '../shared/types';
 import { parsedFilesToRenderableBundle } from './adapters/renderable-bundle';
-import { reflectSourceCode } from './reflection/reflect-source';
-import { checkForReflectionErrors } from './reflection/error-handling';
+import { reflectBundles } from './reflection/reflect-source';
 import { addInheritanceChainToTypes } from './reflection/inheritance-chain-expanion';
 import { addInheritedMembersToTypes } from './reflection/inherited-member-expansion';
 import { convertToDocumentationBundle } from './adapters/renderable-to-page-data';
@@ -42,7 +40,7 @@ export type MarkdownGeneratorConfig = Pick<
   | 'transformDocs'
   | 'transformDocPage'
   | 'transformReference'
-  | 'documentationRootDir'
+  | 'linkingStrategy'
 > & {
   referenceGuideTemplate: string;
   sortMembersAlphabetically: boolean;
@@ -63,15 +61,13 @@ export function generateDocs(apexBundles: UnparsedSourceFile[], config: Markdown
 
   return pipe(
     apexBundles,
-    reflectSourceCode,
-    checkForReflectionErrors,
-    E.map(filterOutOfScope),
-    E.map(addInheritedMembersToTypes),
-    E.map(addInheritanceChainToTypes),
-    E.map(sortTypeMembers),
-    E.bindTo('parsedFiles'),
-    E.bind('references', ({ parsedFiles }) => E.right(convertToReferences(parsedFiles))),
-    TE.fromEither,
+    reflectBundles,
+    TE.map(filterOutOfScope),
+    TE.map(addInheritedMembersToTypes),
+    TE.map(addInheritanceChainToTypes),
+    TE.map(sortTypeMembers),
+    TE.bindTo('parsedFiles'),
+    TE.bind('references', ({ parsedFiles }) => TE.right(convertToReferences(parsedFiles))),
     TE.flatMap(({ parsedFiles, references }) => transformReferenceHook(config)({ references, parsedFiles })),
     TE.map(({ parsedFiles, references }) => convertToRenderableBundle(parsedFiles, references)),
     TE.map(convertToDocumentationBundleForTemplate),

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

@@ -1,45 +1,123 @@
 import { ParsedFile, UnparsedSourceFile } from '../../shared/types';
+import * as TE from 'fp-ts/TaskEither';
 import * as E from 'fp-ts/Either';
-import { reflect as mirrorReflection, Type } from '@cparra/apex-reflection';
+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 { ReflectionError } from './error-handling';
+import { ParsingError } from '@cparra/apex-reflection';
+import { apply } from '#utils/fp';
+import { Semigroup } from 'fp-ts/Semigroup';
 
-export function reflectSourceCode(apexBundles: UnparsedSourceFile[]) {
-  return apexBundles.map(reflectSourceBody);
+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 reflectSourceBody(apexBundle: UnparsedSourceFile): E.Either<ReflectionError, ParsedFile> {
-  const { filePath, content: input, metadataContent: metadata } = apexBundle;
-  const result = mirrorReflection(input);
-  return result.error
-    ? E.left(new ReflectionError(filePath, result.error.message))
-    : E.right({
-        source: {
-          filePath,
-          name: result.typeMirror!.name,
-          type: result.typeMirror!.type_name,
-        },
-        type: addFileMetadataToTypeAnnotation(result.typeMirror!, metadata),
-      });
+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 addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
+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((metadata) => {
-      const metadataParams = parseApexMetadata(metadata);
-      metadataParams.forEach((value, key) => {
-        const declaration = `${key}: ${value}`;
-        type.annotations.push({
-          rawDeclaration: declaration,
-          name: declaration,
-          type: declaration,
-        });
-      });
-      return type;
-    }),
-    O.getOrElse(() => type),
+    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/openapi/open-api-docs-processor.ts

@@ -25,7 +25,7 @@ export class OpenApiDocsProcessor {
   }
 
   onProcess(type: Type): void {
-    Logger.logSingle(`Processing ${type.name}`, false, 'green', false);
+    Logger.logSingle(`Processing ${type.name}`, 'green');
 
     const endpointPath = this.getEndpointPath(type);
     if (!endpointPath) {

package/src/core/openapi/openapi-type-file.ts

@@ -4,7 +4,7 @@ import { OpenApiPageData } from '../shared/types';
 export function createOpenApiFile(fileName: string, openApiModel: OpenApi): OpenApiPageData {
   const content = JSON.stringify({ ...openApiModel, namespace: undefined }, null, 2);
   return {
-    filePath: '',
+    outputDocPath: '',
     content,
     frontmatter: null,
     group: null,

package/src/core/openapi/parser.ts

@@ -1,5 +1,4 @@
 import { ClassMirror, InterfaceMirror, ReflectionResult, Type } from '@cparra/apex-reflection';
-import { parseApexMetadata } from '../parse-apex-metadata';
 import { Logger } from '#utils/logger';
 import { UnparsedSourceFile } from '../shared/types';
 
@@ -16,20 +15,7 @@ export class RawBodyParser implements TypeParser {
     const types = this.typeBundles
       .map((currentBundle) => {
         Logger.log(`Parsing file: ${currentBundle.filePath}`);
-        const result = reflect(currentBundle);
-        if (!!result.typeMirror && !!currentBundle.metadataContent) {
-          // If successful and there is a metadata file
-          const metadataParams = parseApexMetadata(currentBundle.metadataContent);
-          metadataParams.forEach((value, key) => {
-            const declaration = `${key}: ${value}`;
-            result.typeMirror?.annotations.push({
-              rawDeclaration: declaration,
-              name: declaration,
-              type: declaration,
-            });
-          });
-        }
-        return result;
+        return reflect(currentBundle);
       })
       .filter((reflectionResult) => {
         return reflectionResult.typeMirror;

package/src/core/parse-apex-metadata.ts

@@ -1,13 +1,29 @@
 import { XMLParser } from 'fast-xml-parser';
+import * as E from 'fp-ts/Either';
+import { pipe } from 'fp-ts/function';
+
+type ApexMetadata = {
+  ApexClass: ApexClassMetadata;
+};
+
+type ApexClassMetadata = {
+  apiVersion: string;
+  status?: string;
+};
 
 export function parseApexMetadata(input: string) {
-  const map = new Map<string, string>();
-  const xml = new XMLParser().parse(input);
+  return pipe(input, parse, E.map(toMap));
+}
 
-  map.set('apiVersion', xml.ApexClass.apiVersion ?? '');
+function parse(input: string): E.Either<Error, ApexMetadata> {
+  return E.tryCatch(() => new XMLParser().parse(input), E.toError);
+}
 
-  if (xml.ApexClass.status) {
-    map.set('status', xml.ApexClass.status);
+function toMap(metadata: ApexMetadata): Map<string, string> {
+  const map = new Map<string, string>();
+  map.set('apiVersion', String(metadata.ApexClass.apiVersion));
+  if (metadata.ApexClass.status) {
+    map.set('status', String(metadata.ApexClass.status));
   }
 
   return map;

package/src/core/shared/types.d.ts

@@ -12,6 +12,17 @@ export type ConfigurableHooks = {
   transformReference: TransformReference;
 };
 
+type LinkingStrategy =
+  // Links will be generated using relative paths.
+  | 'relative'
+  // No links will be generated.
+  // If the reference is found, the display name will be used.
+  // Otherwise, the name
+  // of the reference itself will be used.
+  | 'no-link'
+  // No logic will be applied, the reference path will be used as is.
+  | 'none';
+
 export type UserDefinedMarkdownConfig = {
   targetGenerator: 'markdown';
   sourceDir: string;
@@ -21,7 +32,7 @@ export type UserDefinedMarkdownConfig = {
   namespace?: string;
   sortMembersAlphabetically: boolean;
   includeMetadata: boolean;
-  documentationRootDir: string;
+  linkingStrategy: LinkingStrategy;
 } & Partial<ConfigurableHooks>;
 
 export type UserDefinedOpenApiConfig = {
@@ -55,8 +66,13 @@ export type DocPageReference = {
   // The name under which the type should be displayed in the documentation.
   // By default, this will match the source.name, but it can be configured by the user.
   displayName: string;
-  // The location of the file relative to the root of the documentation.
-  pathFromRoot: string;
+  // The location where the file will be written.
+  outputDocPath: string;
+  // The path to the file relative to the documentation root directory. This is used when linking to the file.
+  // Usually the value will be the same as outputDocPath. However, some site generators may have a different way of
+  // organizing the files, so this allows for the flexibility of having a path from linking that is different from
+  // the path where the file is written.
+  referencePath: string;
 };
 
 type Frontmatter = string | Record<string, unknown> | null;
@@ -64,13 +80,13 @@ type Frontmatter = string | Record<string, unknown> | null;
 export type ReferenceGuidePageData = {
   frontmatter: Frontmatter;
   content: string;
-  filePath: string;
+  outputDocPath: string;
 };
 
 export type DocPageData = {
   source: SourceFileMetadata;
   group: string | null;
-  filePath: string;
+  outputDocPath: string;
   frontmatter: Frontmatter;
   content: string;
 };
@@ -100,7 +116,7 @@ export type PostHookDocumentationBundle = {
 
 type ConfigurableDocPageReference = Omit<DocPageReference, 'source'>;
 
-type ConfigurableDocPageData = Omit<DocPageData, 'source' | 'filePath'>;
+type ConfigurableDocPageData = Omit<DocPageData, 'source' | 'outputDocPath'>;
 
 /**
  * Allows changing where the files are written to.

package/src/defaults.ts

@@ -5,5 +5,5 @@ export const defaults = {
   defaultGroupName: 'Miscellaneous',
   includeMetadata: false,
   sortMembersAlphabetically: false,
-  documentationRootDir: '',
+  linkingStrategy: 'relative' as const,
 };

package/src/index.ts

@@ -12,12 +12,7 @@ import { defaults } from './defaults';
 type ConfigurableMarkdownConfig = Omit<
   SetOptional<
     UserDefinedMarkdownConfig,
-    | 'targetDir'
-    | 'scope'
-    | 'defaultGroupName'
-    | 'includeMetadata'
-    | 'sortMembersAlphabetically'
-    | 'documentationRootDir'
+    'targetDir' | 'scope' | 'defaultGroupName' | 'includeMetadata' | 'sortMembersAlphabetically' | 'linkingStrategy'
   >,
   'targetGenerator'
 >;

package/src/util/logger.ts

@@ -1,14 +1,10 @@
 import chalk from 'chalk';
-import logUpdate from 'log-update';
-
 /**
  * Logs messages to the console.
  */
 export class Logger {
   static currentFrame = 0;
 
-  static frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-
   /**
    * Logs a message with optional arguments.
    * @param message The message to log.
@@ -27,31 +23,22 @@ export class Logger {
    * @param args Optional arguments.
    */
   public static error(message: unknown, ...args: string[]) {
-    this.logSingle(message, false, 'red', false);
+    this.logSingle(message, 'red');
     args.forEach(() => {
-      this.logSingle(message, false, 'red', false);
+      this.logSingle(message, 'red');
     });
   }
 
-  public static logSingle(text: unknown, showSpinner = true, color: 'green' | 'red' = 'green', overrideConsole = true) {
+  public static logSingle(text: unknown, color: 'green' | 'red' = 'green') {
     if (this.currentFrame > 9) {
       this.currentFrame = 0;
     }
-    const spinner = showSpinner ? `${this.frames[this.currentFrame++]}` : '';
-    let logMessage;
-    if (color === 'green') {
-      logMessage = `${chalk.green(new Date().toLocaleString() + ': ')}${text}\n`;
-    } else {
-      logMessage = `${chalk.red(new Date().toLocaleString() + ': ')}${text}\n`;
-    }
-    if (overrideConsole) {
-      logUpdate(`${spinner} ${logMessage}`);
-    } else {
-      process.stdout.write(`${spinner} ${logMessage}`);
-    }
+
+    const logMessage = `${this.getChalkFn(color)(new Date().toLocaleString() + ': ')}${text}\n`;
+    process.stdout.write(logMessage);
   }
 
-  public static clear() {
-    logUpdate.clear();
+  private static getChalkFn(color: 'green' | 'red') {
+    return color === 'green' ? chalk.green : chalk.red;
   }
 }

package/dist/defaults-DUwru49Q.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const defaults = {
-  targetGenerator: "markdown",
-  targetDir: "./docs/",
-  scope: ["global"],
-  defaultGroupName: "Miscellaneous",
-  includeMetadata: false,
-  sortMembersAlphabetically: false
-};
-
-exports.defaults = defaults;

package/dist/defaults-SH0Rsi5E.js

@@ -1,11 +0,0 @@
-'use strict';
-
-const defaults = {
-  targetGenerator: "markdown",
-  targetDir: "./docs/",
-  scope: ["global"],
-  defaultGroupName: "Miscellaneous",
-  includeMetadata: false
-};
-
-exports.defaults = defaults;

package/src/core/markdown/reflection/error-handling.ts

@@ -1,37 +0,0 @@
-import * as E from 'fp-ts/Either';
-import { ParsedFile } from '../../shared/types';
-import { pipe } from 'fp-ts/function';
-
-export class ReflectionErrors {
-  readonly _tag = 'ReflectionErrors';
-  constructor(public errors: ReflectionError[]) {}
-}
-
-export class ReflectionError {
-  constructor(
-    public file: string,
-    public message: string,
-  ) {}
-}
-
-export function checkForReflectionErrors(reflectionResult: E.Either<ReflectionError, ParsedFile>[]) {
-  function reduceReflectionResultIntoSingleEither(results: E.Either<ReflectionError, ParsedFile>[]): {
-    errors: ReflectionError[];
-    parsedFiles: ParsedFile[];
-  } {
-    return results.reduce<{ errors: ReflectionError[]; parsedFiles: ParsedFile[] }>(
-      (acc, result) => {
-        E.isLeft(result) ? acc.errors.push(result.left) : acc.parsedFiles.push(result.right);
-        return acc;
-      },
-      {
-        errors: [],
-        parsedFiles: [],
-      },
-    );
-  }
-
-  return pipe(reflectionResult, reduceReflectionResultIntoSingleEither, ({ errors, parsedFiles }) =>
-    errors.length ? E.left(new ReflectionErrors(errors)) : E.right(parsedFiles),
-  );
-}