break types out into dedicated files

Author: Mat Jones

src/index.ts

@@ -54,12 +54,12 @@ export { User } from "./interfaces/user";
 // #region Types
 // -----------------------------------------------------------------------------------------
 
-export { AsyncWorkload } from "./types/do-try-types";
+export { AsyncWorkload } from "./types/async-workload";
 export { CancellablePromise } from "./types/cancellable-promise";
-export { CatchHandler } from "./types/do-try-types";
+export { CatchResultHandler } from "./types/catch-result-handler";
 export { Constructor } from "./types/constructor";
-export { FinallyHandler } from "./types/do-try-types";
-export { SyncWorkload } from "./types/do-try-types";
+export { FinallyHandler } from "./types/finally-handler";
+export { SyncWorkload } from "./types/sync-workload";
 
 // #endregion Types
 

src/interfaces/do-try-config.ts

@@ -0,0 +1,13 @@
+import { CatchResultHandler } from "../types/catch-result-handler";
+
+interface DoTryConfig {
+    /**
+     * A default handler that will always run on error, if configured,
+     * even if a `catch()` does not exist in the call chain.
+     * This is useful for adding default error handling in the
+     * development environment, such as `console.error(err)`.
+     */
+    defaultErrorHandler?: CatchResultHandler<any>;
+}
+
+export { DoTryConfig };

src/types/async-workload.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents an asynchronous method reference.
+ */
+type AsyncWorkload<T> = () => Promise<T>;
+
+export { AsyncWorkload };

src/types/catch-result-handler.ts

@@ -0,0 +1,8 @@
+import { ResultRecord } from "../view-models/result-record";
+
+/**
+ * Handler for a typed error ResultRecord, or any type if a Javascript error occurred.
+ */
+type CatchResultHandler<T> = (result?: ResultRecord<T>, error?: any) => void;
+
+export { CatchResultHandler };

src/types/do-try-types.ts

@@ -0,0 +1,6 @@
+/**
+ * Handler for Do.try().finally(); Runs whether an error occurred or not.
+ */
+type FinallyHandler = () => void;
+
+export { FinallyHandler };

src/types/finally-handler.ts

@@ -0,0 +1,6 @@
+/**
+ * Represents a synchronous method reference.
+ */
+type SyncWorkload<T> = () => T;
+
+export { SyncWorkload };

src/types/sync-workload.ts

@@ -8,7 +8,7 @@ import { Do, DoSync } from "../utilities/do-try";
 import { PolyfillUtils } from "../utilities/polyfill-utils";
 import { StubResourceRecord } from "../tests/stubs/stub-resource-record";
 import { CoreUtils } from "../utilities/core-utils";
-import { CatchHandler } from "../types/do-try-types";
+import { CatchResultHandler } from "../types/catch-result-handler";
 
 PolyfillUtils.registerPromiseFinallyPolyfill();
 
@@ -123,7 +123,7 @@ describe("do-try.ts", () => {
     describe("Do.configure", () => {
         it("When defaultErrorHandler configured and catch() is in call chain, then defaultErrorHandler is still executed", async () => {
             // Arrange
-            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            const defaultErrorHandler: CatchResultHandler<any> = jest.fn();
             Do.configure({ defaultErrorHandler });
             const catchHandler = jest.fn();
             const workload = async () => {
@@ -142,7 +142,7 @@ describe("do-try.ts", () => {
 
         it("When defaultErrorHandler configured and no catch() is in call chain, the defaultErrorHandler is still executed", async () => {
             // Arrange
-            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            const defaultErrorHandler: CatchResultHandler<any> = jest.fn();
             Do.configure({ defaultErrorHandler });
             const workload = async () => {
                 throw Error();
@@ -245,7 +245,7 @@ describe("do-try.ts", () => {
     describe("DoSync.configure", () => {
         it("When defaultErrorHandler configured and catch() in call chain, then defaultErrorHandler is still executed", () => {
             // Arrange
-            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            const defaultErrorHandler: CatchResultHandler<any> = jest.fn();
             DoSync.configure({ defaultErrorHandler });
             const catchHandler = jest.fn();
             const workload = () => {
@@ -264,7 +264,7 @@ describe("do-try.ts", () => {
 
         it("When defaultErrorHandler configured and no catch() is in call chain, the defaultErrorHandler is still executed", () => {
             // Arrange
-            const defaultErrorHandler: CatchHandler<any> = jest.fn();
+            const defaultErrorHandler: CatchResultHandler<any> = jest.fn();
             DoSync.configure({ defaultErrorHandler });
             const workload = () => {
                 throw Error();

src/utilities/do-try.test.ts

@@ -1,11 +1,9 @@
 import { ResultRecord } from "../view-models/result-record";
-import {
-    AsyncWorkload,
-    CatchHandler,
-    DoTryConfig,
-    FinallyHandler,
-    SyncWorkload,
-} from "../types/do-try-types";
+import { DoTryConfig } from "../interfaces/do-try-config";
+import { AsyncWorkload } from "../types/async-workload";
+import { CatchResultHandler } from "../types/catch-result-handler";
+import { FinallyHandler } from "../types/finally-handler";
+import { SyncWorkload } from "../types/sync-workload";
 
 // -----------------------------------------------------------------------------------------
 // #region Do
@@ -46,7 +44,7 @@ class Do<TResourceType, TReturnVal = void> {
      * @returns this
      */
     public catch(
-        errorHandler: CatchHandler<TResourceType>
+        errorHandler: CatchResultHandler<TResourceType>
     ): Do<TResourceType, TReturnVal> {
         this.promise = this.promise.catch((err: any) => {
             if (err instanceof ResultRecord) {
@@ -134,7 +132,7 @@ class DoSync<TResourceType, TReturnVal = void> {
      * @param errorHandler handle errors, either as a {ResultRecord} or {any}
      */
     public catch(
-        errorHandler: CatchHandler<TResourceType>
+        errorHandler: CatchResultHandler<TResourceType>
     ): DoSync<TResourceType, TReturnVal> {
         this.catchHandler = (err: any) => {
             if (err instanceof ResultRecord) {