added prettier and export types

package.json

@@ -8,6 +8,7 @@
     "test-ci": "c8 node --require ts-node/register --test test/*.spec.ts",
     "build": "tsc -p tsconfig.json",
     "build-watch": "tsc -p tsconfig.json --watch",
+    "format": "prettier --check **/*.ts",
     "lint": "eslint . --ext .ts"
   },
   "repository": {
@@ -30,6 +31,7 @@
     "@typescript-eslint/parser": "^6.9.1",
     "c8": "^9.0.0",
     "eslint": "^8.53.0",
+    "prettier": "^3.2.4",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2"
   }

src/counter.ts

@@ -1,31 +1,32 @@
 import { EventEmitter } from "events";
 
 type Counter = {
-    incrementCounter: () => void;
-    decrementCounter: () => void;
-    getCount: () => number;
-    registerSubscriberToCounterChanges(callback: (count: number) => void): void;
-}
+  incrementCounter: () => void;
+  decrementCounter: () => void;
+  getCount: () => number;
+  registerSubscriberToCounterChanges(callback: (count: number) => void): void;
+};
 
 export function createCounter(): Counter {
+  const eventEmitter: EventEmitter = new EventEmitter();
+  let count = 0;
 
-    const eventEmitter: EventEmitter = new EventEmitter();
-    let count = 0;
-
-    return {
-        incrementCounter(): void {
-            count++;
-            eventEmitter.emit("counterUpdate", count);
-        },
-        decrementCounter(): void {
-            count--;
-            eventEmitter.emit("counterUpdate", count);
-        },
-        getCount(): number {
-            return count;
-        },
-        registerSubscriberToCounterChanges(callback: (count: number) => void): void {
-            eventEmitter.on("counterUpdate", callback);
-        },
-    };
+  return {
+    incrementCounter(): void {
+      count++;
+      eventEmitter.emit("counterUpdate", count);
+    },
+    decrementCounter(): void {
+      count--;
+      eventEmitter.emit("counterUpdate", count);
+    },
+    getCount(): number {
+      return count;
+    },
+    registerSubscriberToCounterChanges(
+      callback: (count: number) => void,
+    ): void {
+      eventEmitter.on("counterUpdate", callback);
+    },
+  };
 }

src/errors/abort-error.ts

@@ -1,3 +1,3 @@
-export default class AbortError extends Error {
+export class AbortError extends Error {
   public name = "AbortError";
 }

src/errors/closing-error.ts

@@ -1,3 +1,3 @@
-export default class ClosingError extends Error {
-   public name = "ClosingError";
+export class ClosingError extends Error {
+  public name = "ClosingError";
 }

src/errors/timeout-closing-error.ts

@@ -1,3 +1,3 @@
-export default class TimeoutClosingError extends Error {
-    public name = "TimeoutClosingError";
+export class TimeoutClosingError extends Error {
+  public name = "TimeoutClosingError";
 }

src/fire-and-forgetter.ts

@@ -1,7 +1,7 @@
 import { createCounter } from "./counter";
-import AbortError from "./errors/abort-error";
-import ClosingError from "./errors/closing-error";
-import TimeoutClosingError from "./errors/timeout-closing-error";
+import { AbortError } from "./errors/abort-error";
+import { ClosingError } from "./errors/closing-error";
+import { TimeoutClosingError } from "./errors/timeout-closing-error";
 
 type InternalOptions = {
   defaultOnError: (error) => void;
@@ -10,11 +10,11 @@ type InternalOptions = {
 
 type Options = Partial<InternalOptions>;
 
-type FireAndForgetter = {
+export type FireAndForgetter = {
   close: (options?: CloseOptions) => Promise<void>;
 } & ((
   func: (signal: AbortSignal) => Promise<void>,
-  onError?: (error) => void
+  onError?: (error) => void,
 ) => void);
 
 type CloseOptions = {
@@ -52,7 +52,7 @@ export function fireAndForgetter(options?: Options): FireAndForgetter {
    */
   function fireAndForget(
     func: (signal: AbortSignal) => Promise<void>,
-    onError: (error) => void = defaultOnError
+    onError: (error) => void = defaultOnError,
   ): void {
     if (closing) {
       handleClosing(onError);
@@ -63,7 +63,7 @@ export function fireAndForgetter(options?: Options): FireAndForgetter {
 
   async function fire(
     func: (signal: AbortSignal) => Promise<void>,
-    onError: (error) => void
+    onError: (error) => void,
   ): Promise<void> {
     try {
       counter.incrementCounter();
@@ -77,7 +77,7 @@ export function fireAndForgetter(options?: Options): FireAndForgetter {
 
   function handleClosing(onError: (error) => void) {
     const closingError = new ClosingError(
-      "Cannot longer execute fire and forget operation as is closing or closed"
+      "Cannot longer execute fire and forget operation as is closing or closed",
     );
     if (throwOnClosing) {
       throw closingError;
@@ -116,10 +116,10 @@ export function fireAndForgetter(options?: Options): FireAndForgetter {
           () =>
             reject(
               new TimeoutClosingError(
-                `Cannot close after ${timeout}ms, ${counter.getCount()} fire and forget operations are still in progress`
-              )
+                `Cannot close after ${timeout}ms, ${counter.getCount()} fire and forget operations are still in progress`,
+              ),
             ),
-          timeout
+          timeout,
         );
       }
     });

src/index.ts

@@ -1,2 +1,7 @@
-import { fireAndForgetter } from "./fire-and-forgetter";
-export default fireAndForgetter;
+export {
+  fireAndForgetter as default,
+  FireAndForgetter,
+} from "./fire-and-forgetter";
+export * from "./errors/abort-error";
+export * from "./errors/closing-error";
+export * from "./errors/timeout-closing-error";

test/index.spec.ts

@@ -1,11 +1,12 @@
-import ClosingError from "../src/errors/closing-error";
-import TimeoutClosingError from "../src/errors/timeout-closing-error";
-import fireAndForgetter from "../src/index";
 import { describe, test, mock } from "node:test";
 import { equal } from "assert/strict";
 import { setTimeout as sleep } from "timers/promises";
-import AbortError from "../src/errors/abort-error";
 import { notEqual } from "assert";
+import fireAndForgetter, {
+  ClosingError,
+  TimeoutClosingError,
+  AbortError,
+} from "../src/index";
 
 console.error = mock.fn();
 
@@ -87,7 +88,7 @@ describe("fire-and-forgetter", () => {
       equal(error instanceof TimeoutClosingError, true);
       equal(
         (error as Error).message,
-        "Cannot close after 10ms, 3 fire and forget operations are still in progress"
+        "Cannot close after 10ms, 3 fire and forget operations are still in progress",
       );
       equal(count, 0);
       functionHasThrownError = true;
@@ -114,7 +115,7 @@ describe("fire-and-forgetter", () => {
         equal(error instanceof Error, true);
         equal((error as Error).message, "ups, some error happened");
         onErrorHasBeenCalled = true;
-      }
+      },
     );
 
     await fireAndForget.close();
@@ -163,7 +164,7 @@ describe("fire-and-forgetter", () => {
       equal(error instanceof ClosingError, true);
       equal(
         (error as Error).message,
-        "Cannot longer execute fire and forget operation as is closing or closed"
+        "Cannot longer execute fire and forget operation as is closing or closed",
       );
       functionHasThrownError = true;
     }
@@ -194,7 +195,7 @@ describe("fire-and-forgetter", () => {
     equal(reportedError instanceof ClosingError, true);
     equal(
       (reportedError as Error).message,
-      "Cannot longer execute fire and forget operation as is closing or closed"
+      "Cannot longer execute fire and forget operation as is closing or closed",
     );
   });
 });