catch-match 1.1.0 → 3.0.1

package/README.md

@@ -39,6 +39,10 @@ try {
 //> final
 ```
 
+## Features
+
+Supporting sync/async functions
+
 ## Getting started
 
 ```shell
@@ -50,101 +54,96 @@ npm install catch-match
 ```
 
 ```javascript
-import _try from 'catch-match';
-// or
-import { _try } from 'catch-match';
+import $try from 'catch-match';
 // or
-import { _try as customTry } from 'catch-match';
+import { $try } from 'catch-match';
 ```
 
 ## Example 1
+
 ```javascript
-const result = _try(context => {
-    context.tmp = 'any context data';
-    console.log('start', context);
-    return [1, 2, 3, 4, 5]; // value
-}).catch(SyntaxError, (context) => {
-    // noop
-}).catch([TypeError, ReferenceError], (context) => {
-    // noop
-}).other((error, context) => {
-    // noop
-}).finally(({value, context, error}) => {
-    // value: [1, 2, 3, 4, 5] 
-    // context: {tmp: 'any context data'}
-    // error: undefined
-    if (!error) {
-      return value.reverse();
-    }
+const result = $try(() => {
+  throw SyntaxError;
+}).catch(ReferenceError, () => {
+  // noop
+}).catch([TypeError, SyntaxError], () => {
+  // to be called
+}).other((error) => {
+  // noop
+}).finally(({ result, error }) => {
+  return result;
 });
 
-console.log(result); 
-// {
-//     value: [5, 4, 3, 2, 1] 
-//     context: {tmp: 'any context data'}
-//     error: undefined
-// } 
-
+console.log(result); // { error: SyntaxError, result: undefined }
 ```
 
 ## Example 2
+
 ```javascript
-const result = _try(context => {
-  context.tmp = 'any context data';
-  console.log('start', context);
-  // ...
-  throw ReferenceError;
-}).catch(SyntaxError, (context) => {
+const result = $try(() => {
+  return [1, 2, 3];
+}).catch(ReferenceError, () => {
   // noop
-}).catch([TypeError, ReferenceError], (context) => {
-  // context: {tmp: 'any context data'}
-}).other((error, context) => {
+}).catch([TypeError, SyntaxError], () => {
+  // to be called
+}).other((error) => {
   // noop
-}).finally(({value, context, error}) => {
-  // value: undefined 
-  // context: {tmp: 'any context data'}
-  // error: ReferenceError
-  if (!error) {
-    return value.reverse();
-  }
+}).finally(({ result, error }) => {
+  return result;
 });
 
-console.log(result); 
-// {
-//     value: undefined 
-//     context: {tmp: 'any context data'}
-//     error: ReferenceError
-// } 
-
+console.log(result); // {error: undefined, result: [1, 2, 3]}
 ```
 
 ## Example 3
+
 ```javascript
-const result = _try(context => {
-  context.tmp = 'any context data';
-  console.log('start', context);
-  // ...
+const result = $try(() => {
   throw SyntaxError;
-}).catch([TypeError, ReferenceError], (context) => {
-  // noop
-}).other((error, context) => {
-  // error: SyntaxError
-  // context: {tmp: 'any context data'}
-  context.unexpectedError = true;
-}).finally(({value, context, error}) => {
-  // value: undefined 
-  // context: {tmp: 'any context data', unexpectedError: true}
-  // error: SyntaxError
-  if (!error) {
-    return value.reverse();
-  }
-});
+})
+
+console.log(result); // { error: SyntaxError, result: undefined }
+```
+
+## Promises example
+
+```typescript
+class AuthError extends Error {}
+
+function proc(event: string) {
+  return $try(() => new Promise((resolve, reject) => {
+    switch (event) {
+      case 'resolve':
+        resolve('resolved')
+        break;
+      case 'reject':
+        reject('rejected')
+        break;
+      case 'syntax':
+        throw SyntaxError
+      case 'auth':
+        throw AuthError
+      case 'error':
+        throw 'error'
+      default:
+        throw 'other errors'
+    }
+  }).catch('error', () => {
+    // console.log('error')
+  }).catch([SyntaxError, AuthError], (error) => {
+    // console.log(error)
+  }).other((error) => {
+    // console.log(error)
+  }).finally(({ value, error }) => {
+    // console.log({ value, error })
+  })
+}
 
-console.log(result); 
-// {
-//     value: undefined 
-//     context: {tmp: 'any context data', unexpectedError: true}
-//     error: SyntaxError
-// } 
+await proc('resolve') // { value: 'resolved' }}
+await proc('reject')  // { error: 'rejected' }
 
+await proc('syntax')  // { error: SyntaxError }
+await proc('auth')    // { error: AuthError }
+await proc('error')   // { error: 'error' }
+await proc('other')   // { error: 'other errors' }
 ```

package/jest.config.js

@@ -0,0 +1,10 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  globals: {
+    'ts-jest': {
+      tsconfig: 'tsconfig.test.json',
+    },
+  },
+};

package/package.json

@@ -1,16 +1,35 @@
 {
   "name": "catch-match",
-  "version": "1.1.0",
+  "version": "3.0.1",
   "repository": {
     "url": "https://github.com/kobzarvs/catch-match"
   },
-  "keywords": ["try", "catch", "match", "pattern", "errors", "exceptions", "throw", "finally"],
-  "type": "module",
+  "keywords": [
+    "try",
+    "catch",
+    "match",
+    "pattern",
+    "errors",
+    "exceptions",
+    "throw",
+    "finally",
+    "promises",
+    "resolve",
+    "reject",
+    "flow",
+    "control",
+    "process"
+  ],
   "main": "dist/main.js",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@types/jest": "^27.4.0",
+    "jest": "^27.4.7",
+    "ts-jest": "^27.1.3"
   },
-  "devDependencies": {},
   "dependencies": {
     "typescript": "^4.5.4"
   }

package/src/__tests__/main.test.ts

@@ -0,0 +1,502 @@
+import $try, { PromisedTryReturn } from '../main';
+
+describe('sync version', () => {
+  test('should be return result from `finally` branch', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return [1, 2, 3];
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => { //?
+      matchFinally({ value, error });
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: undefined, value: [1, 2, 3] });
+  });
+
+  test('should be match single exception', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw ReferenceError;
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: ReferenceError, value: undefined });
+  });
+
+  test('should be match array of exceptions', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw SyntaxError;
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).toBeCalledWith(SyntaxError);
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: SyntaxError, value: undefined });
+  });
+
+  test('should be match any type of exception', () => {
+    let matchReferenceError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw 'error';
+    }).catch(ReferenceError, () => {
+      matchReferenceError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchReferenceError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: 'error', value: undefined });
+  });
+
+  test('should be match custom exceptions', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch(CustomError, () => {
+      matchCustomError();
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).other((error) => {
+      matchOther(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+    });
+
+    expect(matchCustomError).toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
+
+  test('should be return result from `finally` branch without `other`', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    }).finally(({ value, error }) => {
+      matchFinally({ value, error });
+      return value; // ?
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
+
+  test('should be return result from `catch` branch', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).catch([TypeError, SyntaxError], (error) => {
+      matchArrayOfErrors(error);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
+
+  test('should be return result from `other` branch', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    class CustomError extends Error {
+    }
+
+    const result = $try(() => {
+      throw CustomError;
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).toBeCalledWith(CustomError);
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: CustomError, value: undefined });
+  });
+
+  test('should be return result without branches', () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      throw SyntaxError;
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+    expect(result).toMatchObject({ error: SyntaxError, value: undefined });
+  });
+});
+
+/**
+ * async tests
+ */
+describe('promised version', () => {
+  test('resolve try', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve(42);
+    });
+
+    await result;
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 42,
+      error: undefined,
+    });
+  });
+  test('reject try', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject(42);
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 42,
+    });
+  });
+  test('throw try', async () => {
+    const result = $try(() => {
+      return new Promise(() => {
+        throw new Error('error');
+      });
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+
+    expect(await result).toEqual({
+      value: undefined,
+      error: Error('error'),
+    });
+  });
+
+  test('resolve try.catch', async () => {
+    let matchError = jest.fn();
+    let matchSyntaxError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve(42);
+    }).catch(Error, () => {
+      matchError();
+    }).catch(SyntaxError, () => {
+      matchSyntaxError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchSyntaxError).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 42,
+      error: undefined,
+    });
+  });
+  test('reject try.catch', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject(123);
+    }).catch(Error, () => {
+      matchOther();
+    }).catch(123, () => {
+      matchError();
+    }).catch('error', () => {
+      matchOther();
+    });
+
+    await result; //?
+
+    expect(matchOther).not.toBeCalled();
+    expect(matchError).toBeCalled();
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 123,
+    });
+  });
+  test('throw try.catch', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return new Promise(() => {
+        throw 'error';
+      });
+    }).catch(Error, () => {
+      matchOther();
+    }).catch(123, () => {
+      matchError();
+    }).catch('error', () => {
+      matchOther();
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchOther).toBeCalledTimes(1);
+    expect(matchError).not.toBeCalled();
+  });
+
+  test('resolve try.other', async () => {
+    let matchCustomError = jest.fn();
+    let matchArrayOfErrors = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const result = $try(() => {
+      return Promise.resolve('ok');
+    }).other(({ value, error }) => {
+      matchOther({ value, error });
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: 'ok',
+      error: undefined,
+    });
+
+    expect(matchCustomError).not.toBeCalled();
+    expect(matchArrayOfErrors).not.toBeCalled();
+    expect(matchOther).not.toBeCalled();
+    expect(matchFinally).not.toBeCalled();
+  });
+  test('reject try.other', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return Promise.reject('error');
+    }).catch('error1', () => {
+      matchError();
+    }).catch('error2', () => {
+      matchError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchOther).toBeCalledWith('error');
+  });
+  test('throw try.other', async () => {
+    let matchError = jest.fn();
+    let matchOther = jest.fn();
+
+    const result = $try(() => {
+      return new Promise(() => {
+        throw 'error';
+      });
+    }).catch('error1', () => {
+      matchError();
+    }).catch('error2', () => {
+      matchError();
+    }).other((error) => {
+      matchOther(error);
+    });
+
+    expect(result).toBeInstanceOf(Promise);
+    expect(await result).toEqual({
+      value: undefined,
+      error: 'error',
+    });
+
+    expect(matchError).not.toBeCalled();
+    expect(matchOther).toBeCalledWith('error');
+  });
+
+  test('when throw should be match array or exception', async () => {
+    let matchSingleError = jest.fn();
+    let matchArrayError = jest.fn();
+    let matchOther = jest.fn();
+    let matchFinally = jest.fn();
+
+    const attach = (ctx: PromisedTryReturn<any>) => {
+      return ctx.catch(SyntaxError, () => {
+        matchSingleError(SyntaxError);
+      }).catch([ReferenceError, SyntaxError], (error) => {
+        matchArrayError(error);
+      }).other((error) => {
+        matchOther(error);
+      }).finally(({ value, error }) => {
+        matchFinally({ value, error });
+      });
+    };
+
+    const testSingle = $try(() => new Promise(() => {
+      throw SyntaxError;
+    }));
+
+    const testArray = $try(() => new Promise(() => {
+      throw ReferenceError;
+    }));
+
+    const testOther = $try(() => new Promise(() => {
+      throw TypeError;
+    }));
+
+    const testResolve = $try(() => new Promise((resolve) => {
+      resolve('ok');
+    }));
+
+    const testReject = $try(() => new Promise((_, reject) => {
+      reject('reject');
+    }));
+
+    const resultSingle = attach(testSingle);
+    const resultArray = attach(testArray);
+    const resultOther = attach(testOther);
+    const resultResolve = attach(testResolve);
+    const resultReject = attach(testReject);
+
+    expect(resultSingle).toBeInstanceOf(Promise);
+    expect(resultArray).toBeInstanceOf(Promise);
+    expect(resultOther).toBeInstanceOf(Promise);
+    expect(resultResolve).toBeInstanceOf(Promise);
+    expect(resultReject).toBeInstanceOf(Promise);
+
+    expect(await resultSingle).toEqual({
+      value: undefined,
+      error: SyntaxError,
+    });
+    expect(await resultArray).toEqual({
+      value: undefined,
+      error: ReferenceError,
+    });
+    expect(await resultOther).toEqual({
+      value: undefined,
+      error: TypeError,
+    });
+    expect(await resultResolve).toEqual({
+      value: 'ok',
+    });
+    expect(await resultReject).toEqual({
+      error: 'reject',
+    });
+  });
+});

package/src/main.ts

@@ -1,51 +1,124 @@
-type InternalData<T> = {
-  value?: T;
-  error?: any;
-  context?: any;
-};
-
-export function _try<T>(body: (context: any) => T) {
-  let error: any;
-  let result: T;
-  let context: any = {};
-  const isSameInstance = (e1: any) => e1 === error || e1 === error?.constructor;
+export type ErrrorHandler<ErrorType> = (error?: ErrorType) => void
 
-  try {
-    result = body(context);
-  } catch (e) {
-    error = e;
+export type FinallyCallback<Result, ErrorType = any> = (params: ResultType<Result, ErrorType>) => void
+
+export type TryBody<Result> = () => Result | Promise<Result> | never
+
+export type ResultType<Result, ErrorType = any> = {
+  value?: Result;
+  error?: ErrorType;
+}
+
+export type FinallyReturn<Return, ErrorType = any> =
+  ResultType<Return, ErrorType>
+
+export type OtherReturn<Return, ErrorType = any> =
+  FinallyReturn<Return, ErrorType> &
+  {
+    finally: (callback: FinallyCallback<Return, ErrorType>) => ResultType<Return, ErrorType>
   }
 
-  const chain = {
-    catch: (err: any, handler: (context: any) => void) => {
-      if (!err || !handler) {
-        return chain;
-      }
-      if (isSameInstance(err)) {
-        handler && handler(context);
-      } else if (Array.isArray(err)) {
-        err.some(isSameInstance) && handler(context);
+export type CatchReturn<Return, ErrorType = any> =
+  FinallyReturn<Return, ErrorType> &
+  OtherReturn<Return, ErrorType> &
+  {
+    catch: (error: ErrorType | ErrorType[], handler: ErrrorHandler<ErrorType>) => PromisedTryReturn<Return>;
+    other: (handler: ErrrorHandler<ErrorType>) => Pick<PromisedTryReturn<Return>, 'finally' | 'value' | 'error'>,
+  }
+
+export type PromisedTryReturn<Return> =
+  CatchReturn<Return> |
+  (Promise<ResultType<Return>> & CatchReturn<Return>)
+
+export function $try<Return>(body: TryBody<Return>): PromisedTryReturn<Return> {
+  let caught = false;
+  let error: any | { constructor?: any; } | Promise<any | { constructor?: any; }>;
+  let bodyResponse: Return | Promise<Return>;
+  let result: PromisedTryReturn<Return>;
+
+  const isSameError = (e1: any, error: any) => e1 === error || e1 === error?.constructor;
+
+  function handleErrors(err: any[], err2: any, handler: { (error?: any): void; (error?: any): void; (): any }) {
+    if (isSameError(err, err2) || (Array.isArray(err) && err.some(e => isSameError(e, err2)))) {
+      handler(err2);
+      caught = true;
+    }
+  }
+
+  function buildResult(br: typeof bodyResponse): ResultType<Return> | Promise<ResultType<Return>> {
+    if (br instanceof Promise) {
+      const bodyPromise = br as Promise<Return>;
+      return new Promise<ResultType<Return>>(async (resolve) => {
+        bodyPromise.then((response: any) => {
+          resolve({
+            value: response,
+            error: undefined,
+          });
+        }).catch((e: any) => {
+          resolve({
+            value: undefined,
+            error: e,
+          });
+        });
+      });
+    } else {
+      return {
+        value: br,
+        error: undefined,
+      };
+    }
+  }
+
+  const chain: CatchReturn<Return, typeof error> = {
+    catch: (err, handler) => {
+      if (result instanceof Promise) {
+        result.then((response) => {
+          typeof response.error !== 'undefined' && !caught && handleErrors(err, response.error, handler);
+        });
+      } else {
+        error && !caught && handleErrors(err, error, handler);
       }
-      return chain;
+      return result;
     },
-    other: (handler: (error: any, context: any) => void) => {
-      if (error) {
-        handler && handler(error, context);
+
+    other: (callback) => {
+      if (result instanceof Promise) {
+        result.then((response) => {
+          typeof response.error !== 'undefined' && !caught && callback(response.error);
+        });
+      } else {
+        typeof result.error !== 'undefined' && !caught && callback && callback(result.error);
       }
-      return {
-        finally: chain.finally
-      };
+      return result;
     },
-    finally: (callback: (params: InternalData<T>) => T): InternalData<T> => {
-      return {
-        value: callback ? callback({value: result, error, context}) : result,
-        error,
-        context,
-      };
+
+    finally: (callback) => {
+      if (result instanceof Promise) {
+        result.then((response) => {
+          callback(response);
+        });
+      } else {
+        callback({
+          value: result.value,
+          error: result.error,
+        });
+      }
+      return result;
     },
   };
 
-  return chain;
+  try {
+    bodyResponse = body();
+    result = Object.assign(buildResult(bodyResponse), chain);
+  } catch (e) {
+    error = e;
+    result = Object.assign(chain, {
+      value: undefined,
+      error: e,
+    });
+  }
+
+  return result;
 }
 
-export default _try;
+export default $try;

package/tsconfig.json

@@ -3,7 +3,7 @@
     "target": "es6",
     "useDefineForClassFields": true,
     "module": "ESNext",
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "DOM"],
     "moduleResolution": "Node",
     "strict": true,
     "sourceMap": true,
@@ -15,7 +15,7 @@
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "alwaysStrict": true,
-    "outDir": "dist"
+    "outDir": "dist",
   },
   "include": ["./src"]
 }

package/tsconfig.test.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.json"
+}