@cparra/apexdocs 3.0.0-beta.1 → 3.0.0

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

@@ -0,0 +1,168 @@
+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-members.ts → sort-types-and-members.ts}

@@ -3,11 +3,13 @@ import { ParsedFile } from '../../shared/types';
 
 type Named = { name: string };
 
-export function sortMembers(shouldSortMembers: boolean, parsedFiles: ParsedFile[]): ParsedFile[] {
-  return parsedFiles.map((parsedFile) => ({
-    ...parsedFile,
-    type: sortTypeMember(parsedFile.type, shouldSortMembers),
-  }));
+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 {

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

@@ -1,7 +1,7 @@
 export const referenceGuideTemplate = `
-# Apex Reference Guide
+# {{referenceGuideTitle}}
 
-{{#each this}}
+{{#each references}}
 ## {{@key}}
 
 {{#each this}}

package/src/core/openapi/__tests__/open-api-docs-processor.spec.ts

@@ -4,6 +4,9 @@ import { SettingsBuilder } from '../../../test-helpers/SettingsBuilder';
 import { DocCommentBuilder } from '../../../test-helpers/DocCommentBuilder';
 import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
 import { ClassMirrorBuilder } from '../../../test-helpers/ClassMirrorBuilder';
+import { NoLogger } from '../../../util/logger';
+
+const noLogger = new NoLogger();
 
 beforeEach(() => {
   OpenApiSettings.build(new SettingsBuilder().build());
@@ -18,7 +21,7 @@ it('should add a path based on the @UrlResource annotation on the class', functi
     .addAnnotation(new AnnotationBuilder().addElementValue(annotationElementValue).build())
     .build();
 
-  const processor = new OpenApiDocsProcessor();
+  const processor = new OpenApiDocsProcessor(noLogger);
   processor.onProcess(classMirror);
 
   expect(processor.openApiModel.paths).toHaveProperty('Account/');
@@ -33,7 +36,7 @@ it('should respect slashes', function () {
     .addAnnotation(new AnnotationBuilder().addElementValue(annotationElementValue).build())
     .build();
 
-  const processor = new OpenApiDocsProcessor();
+  const processor = new OpenApiDocsProcessor(noLogger);
   processor.onProcess(classMirror);
 
   expect(processor.openApiModel.paths).toHaveProperty('v1/Account/');
@@ -49,7 +52,7 @@ it('should contain a path with a description when the class has an ApexDoc comme
     .withDocComment(new DocCommentBuilder().withDescription('My Description').build())
     .build();
 
-  const processor = new OpenApiDocsProcessor();
+  const processor = new OpenApiDocsProcessor(noLogger);
   processor.onProcess(classMirror);
 
   expect(processor.openApiModel.paths['Account/'].description).toBe('My Description');

package/src/core/openapi/open-api-docs-processor.ts

@@ -11,7 +11,7 @@ export class OpenApiDocsProcessor {
   protected readonly _fileContainer: FileContainer;
   openApiModel: OpenApi;
 
-  constructor() {
+  constructor(private logger: Logger) {
     this._fileContainer = new FileContainer();
     const title = OpenApiSettings.getInstance().getOpenApiTitle();
     if (!title) {
@@ -29,7 +29,7 @@ export class OpenApiDocsProcessor {
   }
 
   onProcess(type: Type): void {
-    Logger.logSingle(`Processing ${type.name}`, 'green');
+    this.logger.logSingle(`Processing ${type.name}`, 'green');
 
     const endpointPath = this.getEndpointPath(type);
     if (!endpointPath) {
@@ -80,7 +80,7 @@ export class OpenApiDocsProcessor {
       (element) => element.key.toLowerCase() === 'urlmapping',
     );
     if (!urlMapping) {
-      Logger.error(`Type does not contain urlMapping annotation ${type.name}`);
+      this.logger.error(`Type does not contain urlMapping annotation ${type.name}`);
       return null;
     }
 

package/src/core/openapi/parser.ts

@@ -9,12 +9,15 @@ export interface TypeParser {
 type NameAware = { name: string };
 
 export class RawBodyParser implements TypeParser {
-  constructor(public typeBundles: UnparsedSourceFile[]) {}
+  constructor(
+    private logger: Logger,
+    public typeBundles: UnparsedSourceFile[],
+  ) {}
 
   parse(reflect: (apexBundle: UnparsedSourceFile) => ReflectionResult): Type[] {
     const types = this.typeBundles
       .map((currentBundle) => {
-        Logger.log(`Parsing file: ${currentBundle.filePath}`);
+        this.logger.log(`Parsing file: ${currentBundle.filePath}`);
         return reflect(currentBundle);
       })
       .filter((reflectionResult) => {

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

@@ -1,17 +1,5 @@
 import { Type } from '@cparra/apex-reflection';
 
-export type Generator = 'markdown' | 'openapi';
-
-/**
- * The configurable hooks that can be used to modify the output of the generator.
- */
-export type ConfigurableHooks = {
-  transformReferenceGuide: TransformReferenceGuide;
-  transformDocs: TransformDocs;
-  transformDocPage: TransformDocPage;
-  transformReference: TransformReference;
-};
-
 type LinkingStrategy =
   // Links will be generated using relative paths.
   | 'relative'
@@ -24,15 +12,17 @@ type LinkingStrategy =
   | 'none';
 
 export type UserDefinedMarkdownConfig = {
-  targetGenerator: 'markdown';
   sourceDir: string;
+  targetGenerator: 'markdown';
   targetDir: string;
   scope: string[];
-  defaultGroupName: string;
   namespace?: string;
-  sortMembersAlphabetically: boolean;
+  defaultGroupName: string;
+  sortAlphabetically: boolean;
   includeMetadata: boolean;
   linkingStrategy: LinkingStrategy;
+  excludeTags: string[];
+  referenceGuideTitle: string;
 } & Partial<ConfigurableHooks>;
 
 export type UserDefinedOpenApiConfig = {
@@ -115,11 +105,21 @@ export type PostHookDocumentationBundle = {
   docs: DocPageData[];
 };
 
-// Configurable Hooks
+// CONFIGURABLE HOOKS
+
+/**
+ * The configurable hooks that can be used to modify the output of the generator.
+ */
+export type ConfigurableHooks = {
+  transformReferenceGuide: TransformReferenceGuide;
+  transformDocs: TransformDocs;
+  transformDocPage: TransformDocPage;
+  transformReference: TransformReference;
+};
 
-type ConfigurableDocPageReference = Omit<DocPageReference, 'source'>;
+export type ConfigurableDocPageReference = Omit<DocPageReference, 'source'>;
 
-type ConfigurableDocPageData = Omit<DocPageData, 'source' | 'outputDocPath'>;
+export type ConfigurableDocPageData = Omit<DocPageData, 'source' | 'outputDocPath'>;
 
 /**
  * Allows changing where the files are written to.

package/src/defaults.ts

@@ -1,9 +1,21 @@
-export const defaults = {
-  targetGenerator: 'markdown' as const,
+const commonDefaults = {
   targetDir: './docs/',
+};
+
+export const markdownDefaults = {
+  ...commonDefaults,
   scope: ['global'],
   defaultGroupName: 'Miscellaneous',
   includeMetadata: false,
-  sortMembersAlphabetically: false,
+  sortAlphabetically: false,
   linkingStrategy: 'relative' as const,
+  referenceGuideTitle: 'Apex Reference Guide',
+  excludeTags: [],
+};
+
+export const openApiDefaults = {
+  ...commonDefaults,
+  fileName: 'openapi',
+  title: 'Apex REST API',
+  apiVersion: '1.0.0',
 };

package/src/index.ts

@@ -1,4 +1,3 @@
-import { SetOptional } from 'type-fest';
 import type {
   ConfigurableHooks,
   Skip,
@@ -6,31 +5,106 @@ import type {
   ReferenceGuidePageData,
   DocPageData,
   DocPageReference,
+  ConfigurableDocPageData,
+  TransformReferenceGuide,
+  TransformDocs,
+  TransformDocPage,
+  TransformReference,
+  ConfigurableDocPageReference,
+  UserDefinedOpenApiConfig,
+  UserDefinedConfig,
 } from './core/shared/types';
-import { defaults } from './defaults';
+import { markdownDefaults, openApiDefaults } from './defaults';
+import { NoLogger } from '#utils/logger';
+import { Apexdocs } from './application/Apexdocs';
+import * as E from 'fp-ts/Either';
 
-type ConfigurableMarkdownConfig = Omit<
-  SetOptional<
-    UserDefinedMarkdownConfig,
-    'targetDir' | 'scope' | 'defaultGroupName' | 'includeMetadata' | 'sortMembersAlphabetically' | 'linkingStrategy'
-  >,
-  'targetGenerator'
->;
+type ConfigurableMarkdownConfig = Omit<Partial<UserDefinedMarkdownConfig>, 'targetGenerator'>;
 
-function defineMarkdownConfig(config: ConfigurableMarkdownConfig): UserDefinedMarkdownConfig {
+/**
+ * Helper function to define a configuration to generate Markdown documentation.
+ * @param config The configuration to use.
+ */
+function defineMarkdownConfig(config: ConfigurableMarkdownConfig): Partial<UserDefinedMarkdownConfig> {
   return {
-    ...defaults,
+    ...markdownDefaults,
     ...config,
-    targetGenerator: 'markdown',
+    targetGenerator: 'markdown' as const,
   };
 }
 
+type ConfigurableOpenApiConfig = Omit<Partial<UserDefinedOpenApiConfig>, 'targetGenerator'>;
+
+/**
+ * Helper function to define a configuration to generate OpenAPI documentation.
+ * @param config The configuration to use.
+ */
+function defineOpenApiConfig(config: ConfigurableOpenApiConfig): Partial<UserDefinedOpenApiConfig> {
+  return {
+    ...openApiDefaults,
+    ...config,
+    targetGenerator: 'openapi' as const,
+  };
+}
+
+/**
+ * Represents a file to be skipped.
+ */
 function skip(): Skip {
   return {
     _tag: 'Skip',
   };
 }
 
-// Exports
+type CallableConfig = Partial<UserDefinedConfig> & { sourceDir: string; targetGenerator: 'markdown' | 'openapi' };
+
+async function process(config: CallableConfig): Promise<void> {
+  const logger = new NoLogger();
+  const configWithDefaults = {
+    ...getDefault(config),
+    ...config,
+  };
+
+  if (!configWithDefaults.sourceDir) {
+    throw new Error('sourceDir is required');
+  }
 
-export { defineMarkdownConfig, skip, ConfigurableHooks, ReferenceGuidePageData, DocPageData, DocPageReference };
+  const result = await Apexdocs.generate(configWithDefaults as UserDefinedConfig, logger);
+  E.match(
+    (errors) => {
+      throw errors;
+    },
+    () => {},
+  )(result);
+}
+
+function getDefault(config: CallableConfig) {
+  switch (config.targetGenerator) {
+    case 'markdown':
+      return markdownDefaults;
+    case 'openapi':
+      return openApiDefaults;
+    default:
+      throw new Error('Unknown target generator');
+  }
+}
+
+export {
+  defineMarkdownConfig,
+  ConfigurableMarkdownConfig,
+  defineOpenApiConfig,
+  ConfigurableOpenApiConfig,
+  skip,
+  TransformReferenceGuide,
+  TransformDocs,
+  TransformDocPage,
+  TransformReference,
+  ConfigurableHooks,
+  ReferenceGuidePageData,
+  DocPageData,
+  DocPageReference,
+  Skip,
+  ConfigurableDocPageData,
+  ConfigurableDocPageReference,
+  process,
+};

package/src/util/error-logger.ts

@@ -2,90 +2,90 @@ import { ClassMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
 import { Logger } from './logger';
 
 export default class ErrorLogger {
-  public static logErrors(types: Type[]): void {
+  public static logErrors(logger: Logger, types: Type[]): void {
     types.forEach((currentType) => {
-      this.logErrorsForSingleType(currentType);
+      this.logErrorsForSingleType(logger, currentType);
     });
   }
 
-  private static logErrorsForSingleType(currentType: Type): void {
-    this.logTypeErrors(currentType);
+  private static logErrorsForSingleType(logger: Logger, currentType: Type): void {
+    this.logTypeErrors(logger, currentType);
 
     if (currentType.type_name === 'class') {
-      this.logErrorsForClass(currentType as ClassMirror);
+      this.logErrorsForClass(logger, currentType as ClassMirror);
     } else if (currentType.type_name === 'interface') {
-      this.logErrorsForInterface(currentType as InterfaceMirror);
+      this.logErrorsForInterface(logger, currentType as InterfaceMirror);
     }
   }
 
-  private static logTypeErrors(currentType: Type, parentType?: Type) {
+  private static logTypeErrors(logger: Logger, currentType: Type, parentType?: Type) {
     if (currentType.docComment?.error) {
       const typeName = parentType ? `${parentType!.name}.${currentType.name}` : currentType.name;
-      Logger.error(`${typeName} - Doc comment parsing error. Level: Type`);
-      Logger.error(`Comment:\n ${currentType.docComment.rawDeclaration}`);
-      Logger.error(currentType.docComment.error);
-      Logger.error('=================================');
+      logger.error(`${typeName} - Doc comment parsing error. Level: Type`);
+      logger.error(`Comment:\n ${currentType.docComment.rawDeclaration}`);
+      logger.error(currentType.docComment.error);
+      logger.error('=================================');
     }
   }
 
-  private static logErrorsForClass(classMirror: ClassMirror, parentType?: Type): void {
+  private static logErrorsForClass(logger: Logger, classMirror: ClassMirror, parentType?: Type): void {
     const typeName = parentType ? `${parentType!.name}.${classMirror.name}` : classMirror.name;
     classMirror.constructors.forEach((currentConstructor) => {
       if (currentConstructor.docComment?.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Constructor`);
-        Logger.error(`Comment:\n ${currentConstructor.docComment.rawDeclaration}`);
-        Logger.error(currentConstructor.docComment.error);
-        Logger.error('=================================');
+        logger.error(`${typeName} - Doc comment parsing error. Level: Constructor`);
+        logger.error(`Comment:\n ${currentConstructor.docComment.rawDeclaration}`);
+        logger.error(currentConstructor.docComment.error);
+        logger.error('=================================');
       }
     });
 
     classMirror.fields.forEach((currentField) => {
       if (currentField.docComment?.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Field`);
-        Logger.error(`Comment:\n ${currentField.docComment.rawDeclaration}`);
-        Logger.error(currentField.docComment.error);
-        Logger.error('=================================');
+        logger.error(`${typeName} - Doc comment parsing error. Level: Field`);
+        logger.error(`Comment:\n ${currentField.docComment.rawDeclaration}`);
+        logger.error(currentField.docComment.error);
+        logger.error('=================================');
       }
     });
 
     classMirror.properties.forEach((currentProperty) => {
       if (currentProperty.docComment?.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Property`);
-        Logger.error(`Comment:\n ${currentProperty.docComment.rawDeclaration}`);
-        Logger.error(currentProperty.docComment.error);
-        Logger.error('=================================');
+        logger.error(`${typeName} - Doc comment parsing error. Level: Property`);
+        logger.error(`Comment:\n ${currentProperty.docComment.rawDeclaration}`);
+        logger.error(currentProperty.docComment.error);
+        logger.error('=================================');
       }
     });
 
     classMirror.methods.forEach((currentMethod) => {
       if (currentMethod.docComment?.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Method`);
-        Logger.error(`Comment:\n ${currentMethod.docComment.rawDeclaration}`);
-        Logger.error(currentMethod.docComment.error);
-        Logger.error('=================================');
+        logger.error(`${typeName} - Doc comment parsing error. Level: Method`);
+        logger.error(`Comment:\n ${currentMethod.docComment.rawDeclaration}`);
+        logger.error(currentMethod.docComment.error);
+        logger.error('=================================');
       }
     });
 
     classMirror.enums.forEach((currentEnum) => {
-      this.logErrorsForSingleType(currentEnum);
+      this.logErrorsForSingleType(logger, currentEnum);
     });
 
     classMirror.interfaces.forEach((currentInterface) => {
-      this.logErrorsForSingleType(currentInterface);
+      this.logErrorsForSingleType(logger, currentInterface);
     });
 
     classMirror.classes.forEach((currentClass) => {
-      this.logErrorsForSingleType(currentClass);
+      this.logErrorsForSingleType(logger, currentClass);
     });
   }
 
-  private static logErrorsForInterface(interfaceMirror: InterfaceMirror): void {
+  private static logErrorsForInterface(logger: Logger, interfaceMirror: InterfaceMirror): void {
     interfaceMirror.methods.forEach((currentMethod) => {
       if (currentMethod.docComment?.error) {
-        Logger.error(`${interfaceMirror.name} - Doc comment parsing error. Level: Method`);
-        Logger.error(`Comment: ${currentMethod.docComment.rawDeclaration}`);
-        Logger.error(currentMethod.docComment.error);
-        Logger.error('=================================');
+        logger.error(`${interfaceMirror.name} - Doc comment parsing error. Level: Method`);
+        logger.error(`Comment: ${currentMethod.docComment.rawDeclaration}`);
+        logger.error(currentMethod.docComment.error);
+        logger.error('=================================');
       }
     });
   }

package/src/util/logger.ts

@@ -1,16 +1,21 @@
 import chalk from 'chalk';
+
+export interface Logger {
+  log(message: string, ...args: string[]): void;
+  error(message: unknown, ...args: string[]): void;
+  logSingle(text: unknown, color?: 'green' | 'red'): void;
+}
+
 /**
  * Logs messages to the console.
  */
-export class Logger {
-  static currentFrame = 0;
-
+export class StdOutLogger {
   /**
    * Logs a message with optional arguments.
    * @param message The message to log.
    * @param args Optional arguments.
    */
-  public static log(message: string, ...args: string[]) {
+  public log(message: string, ...args: string[]) {
     this.logSingle(message);
     args.forEach((arg) => {
       this.logSingle(arg);
@@ -22,23 +27,25 @@ export class Logger {
    * @param message The error message to log.
    * @param args Optional arguments.
    */
-  public static error(message: unknown, ...args: string[]) {
+  public error(message: unknown, ...args: string[]) {
     this.logSingle(message, 'red');
     args.forEach(() => {
       this.logSingle(message, 'red');
     });
   }
 
-  public static logSingle(text: unknown, color: 'green' | 'red' = 'green') {
-    if (this.currentFrame > 9) {
-      this.currentFrame = 0;
-    }
-
+  public logSingle(text: unknown, color: 'green' | 'red' = 'green') {
     const logMessage = `${this.getChalkFn(color)(new Date().toLocaleString() + ': ')}${text}\n`;
     process.stdout.write(logMessage);
   }
 
-  private static getChalkFn(color: 'green' | 'red') {
+  private getChalkFn(color: 'green' | 'red') {
     return color === 'green' ? chalk.green : chalk.red;
   }
 }
+
+export class NoLogger implements Logger {
+  public log() {}
+  public error() {}
+  public logSingle() {}
+}