@cparra/apexdocs 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/cli/generate.js

@@ -2,10 +2,11 @@
 'use strict';
 
 var _function = require('fp-ts/function');
-var E = require('fp-ts/Either');
 var TE = require('fp-ts/TaskEither');
 var yaml = require('js-yaml');
 var path = require('path');
+var T = require('fp-ts/Task');
+var A = require('fp-ts/lib/Array');
 var apexReflection = require('@cparra/apex-reflection');
 var O = require('fp-ts/Option');
 var fastXmlParser = require('fast-xml-parser');
@@ -34,10 +35,11 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
 var TE__namespace = /*#__PURE__*/_interopNamespaceDefault(TE);
 var yaml__namespace = /*#__PURE__*/_interopNamespaceDefault(yaml);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var T__namespace = /*#__PURE__*/_interopNamespaceDefault(T);
+var A__namespace = /*#__PURE__*/_interopNamespaceDefault(A);
 var O__namespace = /*#__PURE__*/_interopNamespaceDefault(O);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
 var yargs__namespace = /*#__PURE__*/_interopNamespaceDefault(yargs);
@@ -145,25 +147,25 @@ function isInlineCode(content) {
   return Object.keys(content).includes("__type") && content.__type === "inline-code";
 }
 
-var __defProp$f = Object.defineProperty;
-var __defProps$f = Object.defineProperties;
-var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
-var __hasOwnProp$f = Object.prototype.hasOwnProperty;
-var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$f = (a, b) => {
+var __defProp$g = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$f.call(b, prop))
-      __defNormalProp$f(a, prop, b[prop]);
-  if (__getOwnPropSymbols$f)
-    for (var prop of __getOwnPropSymbols$f(b)) {
-      if (__propIsEnum$f.call(b, prop))
-        __defNormalProp$f(a, prop, b[prop]);
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
 function adaptDescribable(describable, linkGenerator) {
   return {
     description: describableToRenderableContent(describable, linkGenerator)
@@ -215,7 +217,7 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
   function extractCustomTags(type) {
     var _a2, _b2;
     const baseTags = ["description", "group", "author", "date", "see", "example", "throws", "exception"];
-    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$f(__spreadValues$f({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
+    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$g(__spreadValues$g({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
       name: currentAnnotation.name
     }))) != null ? _b2 : [];
   }
@@ -229,7 +231,7 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
     var _a2, _b2;
     return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === "see").map((currentAnnotation) => currentAnnotation.body)) != null ? _b2 : [];
   }
-  return __spreadProps$f(__spreadValues$f({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+  return __spreadProps$g(__spreadValues$g({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
     annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
     customTags: extractCustomTags(documentable),
     example: {
@@ -244,25 +246,25 @@ function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
   });
 }
 
-var __defProp$e = Object.defineProperty;
-var __defProps$e = Object.defineProperties;
-var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
-var __hasOwnProp$e = Object.prototype.hasOwnProperty;
-var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$e = (a, b) => {
+var __defProp$f = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$e.call(b, prop))
-      __defNormalProp$e(a, prop, b[prop]);
-  if (__getOwnPropSymbols$e)
-    for (var prop of __getOwnPropSymbols$e(b)) {
-      if (__propIsEnum$e.call(b, prop))
-        __defNormalProp$e(a, prop, b[prop]);
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
 function adaptMethod(method, linkGenerator, baseHeadingLevel) {
   var _a, _b, _c;
   function buildTitle(method2) {
@@ -292,7 +294,7 @@ function adaptMethod(method, linkGenerator, baseHeadingLevel) {
     returnType: {
       headingLevel: baseHeadingLevel + 1,
       heading: "Return Type",
-      value: __spreadProps$e(__spreadValues$e({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
+      value: __spreadProps$f(__spreadValues$f({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
         type: linkGenerator(method.typeReference.rawDeclaration)
       })
     },
@@ -351,13 +353,13 @@ function mapParameters(documentable, param, linkGenerator) {
   const paramAnnotation = (_a = documentable.docComment) == null ? void 0 : _a.paramAnnotations.find(
     (pa) => pa.paramName.toLowerCase() === param.name.toLowerCase()
   );
-  return __spreadProps$e(__spreadValues$e({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
+  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
     name: param.name,
     type: linkGenerator(param.typeReference.rawDeclaration)
   });
 }
 function mapThrows(thrown, linkGenerator) {
-  return __spreadProps$e(__spreadValues$e({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
+  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
     type: linkGenerator(thrown.exceptionName)
   });
 }
@@ -392,25 +394,25 @@ function adaptFieldOrProperty(field, linkGenerator, baseHeadingLevel) {
   };
 }
 
-var __defProp$d = Object.defineProperty;
-var __defProps$d = Object.defineProperties;
-var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
-var __hasOwnProp$d = Object.prototype.hasOwnProperty;
-var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$d = (a, b) => {
+var __defProp$e = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
+var __hasOwnProp$e = Object.prototype.hasOwnProperty;
+var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$d.call(b, prop))
-      __defNormalProp$d(a, prop, b[prop]);
-  if (__getOwnPropSymbols$d)
-    for (var prop of __getOwnPropSymbols$d(b)) {
-      if (__propIsEnum$d.call(b, prop))
-        __defNormalProp$d(a, prop, b[prop]);
+    if (__hasOwnProp$e.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b)) {
+      if (__propIsEnum$e.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
 function typeToRenderable(parsedFile, linkGenerator, config) {
   function getRenderable() {
     const { type } = parsedFile;
@@ -423,7 +425,7 @@ function typeToRenderable(parsedFile, linkGenerator, config) {
         return classTypeToClassSource(type, linkGenerator);
     }
   }
-  return __spreadProps$d(__spreadValues$d({}, getRenderable()), {
+  return __spreadProps$e(__spreadValues$e({}, getRenderable()), {
     filePath: parsedFile.source.filePath,
     namespace: config.namespace
   });
@@ -448,7 +450,7 @@ function baseTypeAdapter(type, linkGenerator, baseHeadingLevel) {
   };
 }
 function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "enum"
   }, baseTypeAdapter(enumType, linkGenerator, baseHeadingLevel)), {
     values: {
@@ -456,7 +458,7 @@ function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
       heading: "Values",
       value: enumType.values.map((value) => {
         var _a;
-        return __spreadProps$d(__spreadValues$d({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+        return __spreadProps$e(__spreadValues$e({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
           value: value.name
         });
       })
@@ -464,7 +466,7 @@ function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
   });
 }
 function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "interface"
   }, baseTypeAdapter(interfaceType, linkGenerator, baseHeadingLevel)), {
     extends: interfaceType.extended_interfaces.map(linkGenerator),
@@ -476,7 +478,7 @@ function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadin
   });
 }
 function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$d(__spreadValues$d({
+  return __spreadProps$e(__spreadValues$e({
     type: "class"
   }, baseTypeAdapter(classType, linkGenerator, baseHeadingLevel)), {
     classModifier: classType.classModifier,
@@ -509,7 +511,7 @@ function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1)
       headingLevel: baseHeadingLevel + 1,
       heading: "Classes",
       value: classType.classes.map(
-        (innerClass) => classTypeToClassSource(__spreadProps$d(__spreadValues$d({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
+        (innerClass) => classTypeToClassSource(__spreadProps$e(__spreadValues$e({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
       )
     },
     innerEnums: {
@@ -671,6 +673,45 @@ function parseApexMetadata(input) {
   return map;
 }
 
+var __defProp$d = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
+var __hasOwnProp$d = Object.prototype.hasOwnProperty;
+var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$d.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b)) {
+      if (__propIsEnum$d.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+var __async$5 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 class ReflectionErrors {
   constructor(errors) {
     this.errors = errors;
@@ -683,39 +724,51 @@ class ReflectionError {
     this.message = message;
   }
 }
-function checkForReflectionErrors(reflectionResult) {
-  function reduceReflectionResultIntoSingleEither(results) {
-    return results.reduce(
-      (acc, result) => {
-        E__namespace.isLeft(result) ? acc.errors.push(result.left) : acc.parsedFiles.push(result.right);
-        return acc;
-      },
-      {
-        errors: [],
-        parsedFiles: []
+function reflectAsync(rawSource) {
+  return __async$5(this, null, function* () {
+    return new Promise((resolve, reject) => {
+      const result = apexReflection.reflect(rawSource);
+      if (result.typeMirror) {
+        return resolve(result.typeMirror);
+      } else if (result.error) {
+        return reject(result.error);
+      } else {
+        return reject(new Error("Unknown error"));
       }
-    );
-  }
-  return _function.pipe(
-    reflectionResult,
-    reduceReflectionResultIntoSingleEither,
-    ({ errors, parsedFiles }) => errors.length ? E__namespace.left(new ReflectionErrors(errors)) : E__namespace.right(parsedFiles)
-  );
+    });
+  });
 }
-
-function reflectSourceCode(apexBundles) {
-  return apexBundles.map(reflectSourceBody);
+function myPipeSeq(apexBundles) {
+  const semiGroupReflectionError = {
+    concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
+  };
+  const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
+  return _function.pipe(apexBundles, A__namespace.traverse(Ap)(myPipe));
+}
+function myPipe(apexBundle) {
+  const convertToParsedFile = apply(toParsedFile, apexBundle.filePath);
+  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
+  return _function.pipe(apexBundle, reflectAsTask, TE__namespace.map(convertToParsedFile), TE__namespace.map(withMetadata));
+}
+function reflectAsTask(apexBundle) {
+  return TE__namespace.tryCatch(
+    () => reflectAsync(apexBundle.content),
+    (error) => new ReflectionErrors([new ReflectionError(apexBundle.filePath, error.message)])
+  );
 }
-function reflectSourceBody(apexBundle) {
-  const { filePath, content: input, metadataContent: metadata } = apexBundle;
-  const result = apexReflection.reflect(input);
-  return result.error ? E__namespace.left(new ReflectionError(filePath, result.error.message)) : E__namespace.right({
+function toParsedFile(filePath, typeMirror) {
+  return {
     source: {
       filePath,
-      name: result.typeMirror.name,
-      type: result.typeMirror.type_name
+      name: typeMirror.name,
+      type: typeMirror.type_name
     },
-    type: addFileMetadataToTypeAnnotation(result.typeMirror, metadata)
+    type: typeMirror
+  };
+}
+function addMetadata(rawMetadataContent, parsedFile) {
+  return __spreadProps$d(__spreadValues$d({}, parsedFile), {
+    type: addFileMetadataToTypeAnnotation(parsedFile.type, rawMetadataContent)
   });
 }
 function addFileMetadataToTypeAnnotation(type, metadata) {
@@ -1525,7 +1578,7 @@ var __spreadValues$7 = (a, b) => {
   return a;
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-var __async$2 = (__this, __arguments, generator) => {
+var __async$4 = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
       try {
@@ -1559,15 +1612,14 @@ function generateDocs(apexBundles, config) {
   const sortTypeMembers = apply(sortMembers, config.sortMembersAlphabetically);
   return _function.pipe(
     apexBundles,
-    reflectSourceCode,
-    checkForReflectionErrors,
-    E__namespace.map(filterOutOfScope),
-    E__namespace.map(addInheritedMembersToTypes),
-    E__namespace.map(addInheritanceChainToTypes),
-    E__namespace.map(sortTypeMembers),
-    E__namespace.bindTo("parsedFiles"),
-    E__namespace.bind("references", ({ parsedFiles }) => E__namespace.right(convertToReferences(parsedFiles))),
-    TE__namespace.fromEither,
+    myPipeSeq,
+    //checkForReflectionErrors,
+    TE__namespace.map(filterOutOfScope),
+    TE__namespace.map(addInheritedMembersToTypes),
+    TE__namespace.map(addInheritanceChainToTypes),
+    TE__namespace.map(sortTypeMembers),
+    TE__namespace.bindTo("parsedFiles"),
+    TE__namespace.bind("references", ({ parsedFiles }) => TE__namespace.right(convertToReferences(parsedFiles))),
     TE__namespace.flatMap(({ parsedFiles, references }) => transformReferenceHook(config)({ references, parsedFiles })),
     TE__namespace.map(({ parsedFiles, references }) => convertToRenderableBundle(parsedFiles, references)),
     TE__namespace.map(convertToDocumentationBundleForTemplate),
@@ -1577,7 +1629,7 @@ function generateDocs(apexBundles, config) {
 }
 function transformReferenceHook(config) {
   function _execute(references, parsedFiles, transformReference) {
-    return __async$2(this, null, function* () {
+    return __async$4(this, null, function* () {
       return {
         references: yield execTransformReferenceHook(Object.values(references), transformReference),
         parsedFiles
@@ -1598,8 +1650,8 @@ function transformDocumentationBundleHook(config) {
 function passThroughHook(value) {
   return value;
 }
-const execTransformReferenceHook = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
-  const hooked = references.map((reference) => __async$2(void 0, null, function* () {
+const execTransformReferenceHook = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
+  const hooked = references.map((reference) => __async$4(void 0, null, function* () {
     const hookedResult = yield hook(reference);
     return __spreadValues$7(__spreadValues$7({}, reference), hookedResult);
   }));
@@ -1609,24 +1661,24 @@ const execTransformReferenceHook = (_0, ..._1) => __async$2(void 0, [_0, ..._1],
     return acc;
   }, {});
 });
-const documentationBundleHook = (bundle, config) => __async$2(void 0, null, function* () {
+const documentationBundleHook = (bundle, config) => __async$4(void 0, null, function* () {
   return {
     referenceGuide: yield transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
     docs: yield transformDocs(bundle.docs, config.transformDocs, config.transformDocPage)
   };
 });
-const transformReferenceGuide = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
+const transformReferenceGuide = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
   const result = yield hook(referenceGuide);
   if (isSkip(result)) {
     return result;
   }
   return __spreadValues$7(__spreadValues$7({}, referenceGuide), yield hook(referenceGuide));
 });
-const transformDocs = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
+const transformDocs = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
   const transformed = yield transformDocsHook(docs);
   return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
 });
-const transformDocPage = (_0, ..._1) => __async$2(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
+const transformDocPage = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
   return __spreadValues$7(__spreadValues$7({}, doc), yield hook(doc));
 });
 function postHookCompile(bundle) {
@@ -2797,47 +2849,134 @@ function filterByScopes(manifest) {
   return filteredTypes;
 }
 
+var __async$3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 const APEX_FILE_EXTENSION = ".cls";
 class ApexFileReader {
   /**
    * Reads from .cls files and returns their raw body.
    */
   static processFiles(fileSystem, rootPath, includeMetadata) {
-    let bundles = [];
-    const directoryContents = fileSystem.readDirectory(rootPath);
-    directoryContents.forEach((filePath) => {
-      const currentPath = fileSystem.joinPath(rootPath, filePath);
-      if (fileSystem.isDirectory(currentPath)) {
-        bundles = bundles.concat(this.processFiles(fileSystem, currentPath, includeMetadata));
-      }
-      if (!this.isApexFile(filePath)) {
-        return;
+    return __async$3(this, null, function* () {
+      const filePaths = yield this.getFilePaths(fileSystem, rootPath);
+      const apexFilePaths = filePaths.filter((filePath) => this.isApexFile(filePath));
+      const filePromises = apexFilePaths.map((filePath) => this.processFile(fileSystem, filePath, includeMetadata));
+      return Promise.all(filePromises);
+    });
+  }
+  static getFilePaths(fileSystem, rootPath) {
+    return __async$3(this, null, function* () {
+      const directoryContents = yield fileSystem.readDirectory(rootPath);
+      const paths = [];
+      for (const filePath of directoryContents) {
+        const currentPath = fileSystem.joinPath(rootPath, filePath);
+        if (yield fileSystem.isDirectory(currentPath)) {
+          paths.push(...yield this.getFilePaths(fileSystem, currentPath));
+        }
+        paths.push(currentPath);
       }
-      const rawTypeContent = fileSystem.readFile(currentPath);
-      const metadataPath = fileSystem.joinPath(rootPath, `${filePath}-meta.xml`);
+      return paths;
+    });
+  }
+  static processFile(fileSystem, filePath, includeMetadata) {
+    return __async$3(this, null, function* () {
+      const rawTypeContent = yield fileSystem.readFile(filePath);
+      const metadataPath = `${filePath}-meta.xml`;
       let rawMetadataContent = null;
       if (includeMetadata) {
-        rawMetadataContent = fileSystem.exists(metadataPath) ? fileSystem.readFile(metadataPath) : null;
+        rawMetadataContent = fileSystem.exists(metadataPath) ? yield fileSystem.readFile(metadataPath) : null;
       }
-      bundles.push({ filePath: currentPath, content: rawTypeContent, metadataContent: rawMetadataContent });
+      return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
     });
-    return bundles;
   }
   static isApexFile(currentFile) {
     return currentFile.endsWith(APEX_FILE_EXTENSION);
   }
 }
 
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function stat(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.stat(path2, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+function readdir(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readdir(path2, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+function readFile(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readFile(path2, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+}
 class DefaultFileSystem {
   isDirectory(pathToRead) {
-    return fs__namespace.statSync(pathToRead).isDirectory();
+    return __async$2(this, null, function* () {
+      const stats = yield stat(pathToRead);
+      return stats.isDirectory();
+    });
   }
   readDirectory(sourceDirectory) {
-    return fs__namespace.readdirSync(sourceDirectory);
+    return readdir(sourceDirectory);
   }
   readFile(pathToRead) {
-    const rawFile = fs__namespace.readFileSync(pathToRead);
-    return rawFile.toString();
+    return readFile(pathToRead);
   }
   joinPath(...paths) {
     return path__namespace.join(...paths);
@@ -2875,7 +3014,11 @@ class Apexdocs {
     return __async$1(this, null, function* () {
       Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
       try {
-        const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
+        const fileBodies = yield ApexFileReader.processFiles(
+          new DefaultFileSystem(),
+          config.sourceDir,
+          config.includeMetadata
+        );
         switch (config.targetGenerator) {
           case "markdown":
             yield generate(fileBodies, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cparra/apexdocs",
-  "version": "3.0.0-alpha.7",
+  "version": "3.0.0-alpha.9",
   "description": "Library with CLI capabilities to generate documentation for Salesforce Apex classes.",
   "keywords": [
     "apex",
@@ -58,7 +58,7 @@
     ]
   },
   "dependencies": {
-    "@cparra/apex-reflection": "2.11.3",
+    "@cparra/apex-reflection": "2.12.1",
     "@types/js-yaml": "^4.0.9",
     "@types/yargs": "^17.0.32",
     "chalk": "^4.1.2",

package/src/application/Apexdocs.ts

@@ -17,7 +17,11 @@ export class Apexdocs {
     Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
 
     try {
-      const fileBodies = ApexFileReader.processFiles(new DefaultFileSystem(), config.sourceDir, config.includeMetadata);
+      const fileBodies = await ApexFileReader.processFiles(
+        new DefaultFileSystem(),
+        config.sourceDir,
+        config.includeMetadata,
+      );
 
       switch (config.targetGenerator) {
         case 'markdown':

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

@@ -18,24 +18,24 @@ describe('File Reader', () => {
     } as SettingsConfig);
   });
 
-  it('returns an empty list when there are no files in the directory', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns an empty list when there are no files in the directory', async () => {
+    const result = await ApexFileReader.processFiles(
       {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        isDirectory(_: string): boolean {
-          return false;
+        isDirectory(_: string): Promise<boolean> {
+          return Promise.resolve(false);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         joinPath(_: string): string {
           return '';
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readDirectory(_: string): string[] {
-          return [];
+        readDirectory(_: string): Promise<string[]> {
+          return Promise.resolve([]);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readFile(_: string): string {
-          return '';
+        readFile(_: string): Promise<string> {
+          return Promise.resolve('');
         },
         exists(): boolean {
           return true;
@@ -47,20 +47,20 @@ describe('File Reader', () => {
     expect(result.length).toBe(0);
   });
 
-  it('returns an empty list when there are no Apex files in the directory', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns an empty list when there are no Apex files in the directory', async () => {
+    const result = await ApexFileReader.processFiles(
       {
-        isDirectory(): boolean {
-          return false;
+        isDirectory(): Promise<boolean> {
+          return Promise.resolve(false);
         },
         joinPath(): string {
           return '';
         },
-        readDirectory(): string[] {
-          return ['SomeFile.md'];
+        readDirectory(): Promise<string[]> {
+          return Promise.resolve(['SomeFile.md']);
         },
-        readFile(): string {
-          return '';
+        readFile(): Promise<string> {
+          return Promise.resolve('');
         },
         exists(): boolean {
           return true;
@@ -72,24 +72,24 @@ describe('File Reader', () => {
     expect(result.length).toBe(0);
   });
 
-  it('returns the file contents for an Apex file', () => {
-    const result = ApexFileReader.processFiles(
+  it('returns the file contents for an Apex file', async () => {
+    const result = await ApexFileReader.processFiles(
       {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        isDirectory(_: string): boolean {
-          return false;
+        isDirectory(_: string): Promise<boolean> {
+          return Promise.resolve(false);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         joinPath(_: string): string {
-          return '';
+          return 'SomeApexFile.cls';
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readDirectory(_: string): string[] {
-          return ['SomeApexFile.cls'];
+        readDirectory(_: string): Promise<string[]> {
+          return Promise.resolve(['SomeApexFile.cls']);
         },
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        readFile(_: string): string {
-          return 'public class MyClass{}';
+        readFile(_: string): Promise<string> {
+          return Promise.resolve('public class MyClass{}');
         },
         exists(): boolean {
           return true;

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

@@ -10,30 +10,43 @@ export class ApexFileReader {
   /**
    * Reads from .cls files and returns their raw body.
    */
-  static processFiles(fileSystem: FileSystem, rootPath: string, includeMetadata: boolean): UnparsedSourceFile[] {
-    let bundles: UnparsedSourceFile[] = [];
+  static async processFiles(
+    fileSystem: FileSystem,
+    rootPath: string,
+    includeMetadata: boolean,
+  ): Promise<UnparsedSourceFile[]> {
+    const filePaths = await this.getFilePaths(fileSystem, rootPath);
+    const apexFilePaths = filePaths.filter((filePath) => this.isApexFile(filePath));
+    const filePromises = apexFilePaths.map((filePath) => this.processFile(fileSystem, filePath, includeMetadata));
+    return Promise.all(filePromises);
+  }
 
-    const directoryContents = fileSystem.readDirectory(rootPath);
-    directoryContents.forEach((filePath) => {
+  private static async getFilePaths(fileSystem: FileSystem, rootPath: string): Promise<string[]> {
+    const directoryContents = await fileSystem.readDirectory(rootPath);
+    const paths: string[] = [];
+    for (const filePath of directoryContents) {
       const currentPath = fileSystem.joinPath(rootPath, filePath);
-      if (fileSystem.isDirectory(currentPath)) {
-        bundles = bundles.concat(this.processFiles(fileSystem, currentPath, includeMetadata));
-      }
-
-      if (!this.isApexFile(filePath)) {
-        return;
+      if (await fileSystem.isDirectory(currentPath)) {
+        paths.push(...(await this.getFilePaths(fileSystem, currentPath)));
       }
+      paths.push(currentPath);
+    }
+    return paths;
+  }
 
-      const rawTypeContent = fileSystem.readFile(currentPath);
-      const metadataPath = fileSystem.joinPath(rootPath, `${filePath}-meta.xml`);
-      let rawMetadataContent = null;
-      if (includeMetadata) {
-        rawMetadataContent = fileSystem.exists(metadataPath) ? fileSystem.readFile(metadataPath) : null;
-      }
+  private static async processFile(
+    fileSystem: FileSystem,
+    filePath: string,
+    includeMetadata: boolean,
+  ): Promise<UnparsedSourceFile> {
+    const rawTypeContent = await fileSystem.readFile(filePath);
+    const metadataPath = `${filePath}-meta.xml`;
+    let rawMetadataContent = null;
+    if (includeMetadata) {
+      rawMetadataContent = fileSystem.exists(metadataPath) ? await fileSystem.readFile(metadataPath) : null;
+    }
 
-      bundles.push({ filePath: currentPath, content: rawTypeContent, metadataContent: rawMetadataContent });
-    });
-    return bundles;
+    return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
   }
 
   private static isApexFile(currentFile: string): boolean {

package/src/application/file-system.ts

@@ -2,25 +2,61 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 export interface FileSystem {
-  readDirectory: (sourceDirectory: string) => string[];
-  isDirectory: (path: string) => boolean;
-  readFile: (path: string) => string;
+  isDirectory: (path: string) => Promise<boolean>;
+  readDirectory: (sourceDirectory: string) => Promise<string[]>;
+  readFile: (path: string) => Promise<string>;
   joinPath: (...paths: string[]) => string;
   exists: (path: string) => boolean;
 }
 
+function stat(path: string): Promise<fs.Stats> {
+  return new Promise((resolve, reject) => {
+    fs.stat(path, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+
+function readdir(path: string): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    fs.readdir(path, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+
+function readFile(path: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+}
+
 export class DefaultFileSystem implements FileSystem {
-  isDirectory(pathToRead: string): boolean {
-    return fs.statSync(pathToRead).isDirectory();
+  async isDirectory(pathToRead: string): Promise<boolean> {
+    const stats = await stat(pathToRead);
+    return stats.isDirectory();
   }
 
-  readDirectory(sourceDirectory: string): string[] {
-    return fs.readdirSync(sourceDirectory);
+  readDirectory(sourceDirectory: string): Promise<string[]> {
+    return readdir(sourceDirectory);
   }
 
-  readFile(pathToRead: string): string {
-    const rawFile = fs.readFileSync(pathToRead);
-    return rawFile.toString();
+  readFile(pathToRead: string): Promise<string> {
+    return readFile(pathToRead);
   }
 
   joinPath(...paths: string[]): string {

package/src/application/generators/markdown.ts

@@ -8,10 +8,10 @@ import {
   UnparsedSourceFile,
   UserDefinedMarkdownConfig,
 } from '../../core/shared/types';
-import { ReflectionError } from '../../core/markdown/reflection/error-handling';
 import { referenceGuideTemplate } from '../../core/markdown/templates/reference-guide';
 import * as TE from 'fp-ts/TaskEither';
 import { isSkip } from '../../core/shared/utils';
+import { ReflectionError } from '../../core/markdown/reflection/reflect-source';
 
 class FileWritingError {
   readonly _tag = 'FileWritingError';

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

@@ -1,5 +1,5 @@
 import { pipe } from 'fp-ts/function';
-import * as E from 'fp-ts/Either';
+//import * as E from 'fp-ts/Either';
 import * as TE from 'fp-ts/TaskEither';
 import yaml from 'js-yaml';
 
@@ -20,8 +20,8 @@ import {
   ParsedFile,
 } from '../shared/types';
 import { parsedFilesToRenderableBundle } from './adapters/renderable-bundle';
-import { reflectSourceCode } from './reflection/reflect-source';
-import { checkForReflectionErrors } from './reflection/error-handling';
+import { myPipeSeq /*reflectSourceCode*/ } from './reflection/reflect-source';
+//import { checkForReflectionErrors } from './reflection/error-handling';
 import { addInheritanceChainToTypes } from './reflection/inheritance-chain-expanion';
 import { addInheritedMembersToTypes } from './reflection/inherited-member-expansion';
 import { convertToDocumentationBundle } from './adapters/renderable-to-page-data';
@@ -63,15 +63,14 @@ 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,
+    myPipeSeq,
+    //checkForReflectionErrors,
+    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,34 +1,111 @@
 import { ParsedFile, UnparsedSourceFile } from '../../shared/types';
-import * as E from 'fp-ts/Either';
+//import * as E from 'fp-ts/Either';
+import * as TE from 'fp-ts/TaskEither';
+import * as T from 'fp-ts/Task';
+import * as A from 'fp-ts/lib/Array';
 import { 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';
-
-export function reflectSourceCode(apexBundles: UnparsedSourceFile[]) {
-  return apexBundles.map(reflectSourceBody);
-}
-
-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),
-      });
+import { ParsingError } from '@cparra/apex-reflection/index';
+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 myPipeSeq(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)(myPipe));
+}
+
+function myPipe(apexBundle: UnparsedSourceFile): TE.TaskEither<ReflectionErrors, ParsedFile> {
+  const convertToParsedFile: (typeMirror: Type) => ParsedFile = apply(toParsedFile, apexBundle.filePath);
+  const withMetadata: (parsedFile: ParsedFile) => ParsedFile = apply(addMetadata, apexBundle.metadataContent);
+
+  return pipe(apexBundle, reflectAsTask, TE.map(convertToParsedFile), TE.map(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) {
+  return {
+    ...parsedFile,
+    type: addFileMetadataToTypeAnnotation(parsedFile.type, rawMetadataContent),
+  };
+}
+
+// TODO: Not Async below
+
+// export function reflectSourceCode(apexBundles: UnparsedSourceFile[]) {
+//   return apexBundles.map(reflectSourceBody);
+// }
+//
+// 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 addFileMetadataToTypeAnnotation(type: Type, metadata: string | null): Type {
   return pipe(
     O.fromNullable(metadata),
     O.map((metadata) => {
+      // TODO: Do we need to error check this, as it is coming from an external library?
+      // Or maybe what we do is return the Either from the parse-apex-metadata function?
       const metadataParams = parseApexMetadata(metadata);
       metadataParams.forEach((value, key) => {
         const declaration = `${key}: ${value}`;

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/dist/defaults-jLXD2y8-.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const defaults = {
-  targetGenerator: "markdown",
-  targetDir: "./docs/",
-  scope: ["global"],
-  defaultGroupName: "Miscellaneous",
-  includeMetadata: false,
-  sortMembersAlphabetically: false,
-  documentationRootDir: ""
-};
-
-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),
-  );
-}