catch-match 1.1.0 → 2.0.0

package/README.md

@@ -50,77 +50,51 @@ npm install catch-match
 ```
 
 ```javascript
-import _try from 'catch-match';
+import $try from 'catch-match';
 // or
-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 => {
+const result = $try(context => {
   context.tmp = 'any context data';
   console.log('start', context);
   // ...
@@ -140,7 +114,7 @@ const result = _try(context => {
   }
 });
 
-console.log(result); 
+console.log(result);
 // {
 //     value: undefined 
 //     context: {tmp: 'any context data', unexpectedError: true}

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,29 @@
 {
   "name": "catch-match",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "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"
+  ],
   "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,226 @@
+import $try from '../main';
+
+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], () => {
+    matchArrayOfErrors();
+  }).other((error) => {
+    matchOther(error);
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchReferenceError).not.toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: undefined, result: [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], () => {
+    matchArrayOfErrors();
+  }).other((error) => {
+    matchOther(error);
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchReferenceError).toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: ReferenceError, result: 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], () => {
+    matchArrayOfErrors();
+  }).other((error) => {
+    matchOther(error);
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchReferenceError).not.toBeCalled();
+  expect(matchArrayOfErrors).toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: SyntaxError, result: 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], () => {
+    matchArrayOfErrors();
+  }).other((error) => {
+    matchOther(error);
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchReferenceError).not.toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: 'error', result: 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], () => {
+    matchArrayOfErrors();
+  }).other((error) => {
+    matchOther(error);
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchCustomError).toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: CustomError, result: 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], () => {
+    matchArrayOfErrors();
+  }).finally(({ result, error }) => {
+    matchFinally({ result, error });
+    return result;
+  });
+
+  expect(matchCustomError).not.toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).toBeCalled();
+  expect(result).toEqual({ error: CustomError, result: 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], () => {
+    matchArrayOfErrors();
+  });
+
+  expect(matchCustomError).not.toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).not.toBeCalled();
+  expect(result).toMatchObject({ error: CustomError, result: 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, result: undefined });
+});
+
+
+test('should be return result without branches', () => {
+  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;
+  });
+
+  expect(matchCustomError).not.toBeCalled();
+  expect(matchArrayOfErrors).not.toBeCalled();
+  expect(matchOther).not.toBeCalled();
+  expect(matchFinally).not.toBeCalled();
+  expect(result).toMatchObject({ error: CustomError, result: undefined });
+});

package/src/main.ts

@@ -1,51 +1,71 @@
-type InternalData<T> = {
-  value?: T;
-  error?: any;
-  context?: any;
+export type ResultType<Rsult, ErrorType> = {
+  result?: Rsult;
+  error?: ErrorType;
 };
 
-export function _try<T>(body: (context: any) => T) {
-  let error: any;
-  let result: T;
-  let context: any = {};
+export type ErrrorHandler<ErrorType> = (error?: ErrorType) => void;
+
+export type FinallyCallback<Result, ErrorType> = ((params: ResultType<Result, ErrorType>) => Result | void | undefined);
+
+export type TryReturn<Result, ErrorType = any> = {
+  catch: (error: ErrorType | ErrorType[], handler: ErrrorHandler<ErrorType>) => TryReturn<Result, ErrorType>;
+  other: (handler: ErrrorHandler<ErrorType>) => Pick<TryReturn<Result, ErrorType>, 'finally'>,
+  finally: (callback?: FinallyCallback<Result, ErrorType>) => ResultType<Result, ErrorType>,
+  result: Result,
+  error: ErrorType
+}
+
+export type TryBody<Result> = () => Result | never;
+
+export function $try<Return>(body: TryBody<Return>): TryReturn<Return> {
+  let caught = false;
+  let error: any | { constructor?: any; };
+  let result: Return | any;
   const isSameInstance = (e1: any) => e1 === error || e1 === error?.constructor;
 
   try {
-    result = body(context);
+    result = body();
   } catch (e) {
     error = e;
   }
 
-  const chain = {
-    catch: (err: any, handler: (context: any) => void) => {
+  const chain: TryReturn<typeof result, typeof error> = {
+    catch: (err, handler) => {
       if (!err || !handler) {
         return chain;
       }
       if (isSameInstance(err)) {
-        handler && handler(context);
-      } else if (Array.isArray(err)) {
-        err.some(isSameInstance) && handler(context);
+        handler && handler();
+        caught = true;
+      } else if (Array.isArray(err) && err.some(isSameInstance)) {
+        handler && handler();
+        caught = true;
       }
       return chain;
     },
-    other: (handler: (error: any, context: any) => void) => {
-      if (error) {
-        handler && handler(error, context);
+
+    other: (handler) => {
+      if (!caught && error) {
+        handler && handler(error);
       }
       return {
-        finally: chain.finally
+        finally: chain.finally,
+        result,
+        error,
       };
     },
-    finally: (callback: (params: InternalData<T>) => T): InternalData<T> => {
+
+    finally: (callback?) => {
       return {
-        value: callback ? callback({value: result, error, context}) : result,
+        result: callback ? callback({ result, error }) : result,
         error,
-        context,
       };
     },
+    result,
+    error,
   };
 
   return chain;
 }
 
-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"
+}