Feat: Enhance import process

.gitignore

@@ -47,3 +47,5 @@ yarn-error.log*
 /.run
 
 .env
+
+.gitconfig

src/ElectronBackend/errorHandling/__tests__/errorHandling.test.ts

@@ -9,7 +9,7 @@ import { AllowedFrontendChannels } from '../../../shared/ipc-channels';
 import { SendErrorInformationArgs } from '../../../shared/shared-types';
 import { loadInputAndOutputFromFilePath } from '../../input/importFromFile';
 import {
-  createListenerCallbackWithErrorHandling,
+  createVoidListenerCallbackWithErrorHandling,
   getMessageBoxContentForErrorsWrapper,
   getMessageBoxForErrors,
 } from '../errorHandling';
@@ -46,7 +46,7 @@ describe('error handling', () => {
         arg2: true,
       };
 
-      await createListenerCallbackWithErrorHandling(
+      await createVoidListenerCallbackWithErrorHandling(
         mainWindow,
         testFunction,
       )(testArgs);
@@ -65,7 +65,10 @@ describe('error handling', () => {
         throw new Error('TEST_ERROR');
       }
 
-      await createListenerCallbackWithErrorHandling(mainWindow, testFunction)();
+      await createVoidListenerCallbackWithErrorHandling(
+        mainWindow,
+        testFunction,
+      )();
 
       expect(dialog.showMessageBox).toHaveBeenCalledWith(
         expect.objectContaining({

src/ElectronBackend/errorHandling/errorHandling.ts

@@ -17,32 +17,63 @@ import { getGlobalBackendState } from '../main/globalBackendState';
 import logger from '../main/logger';
 import { getLoadedFilePath } from '../utils/getLoadedFile';
 
-export function createListenerCallbackWithErrorHandling(
+async function reportListenerError(
   mainWindow: BrowserWindow,
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  func: Function,
-): (...args: Array<unknown>) => Promise<void> {
-  return async (...args: Array<unknown>): Promise<void> => {
+  error: unknown,
+): Promise<void> {
+  if (error instanceof Error) {
+    logger.info(`Failed executing callback function: ${error.message}`);
+    await getMessageBoxForErrors(
+      error.message,
+      error.stack ?? '',
+      mainWindow,
+      true,
+    );
+  } else {
+    logger.info('Failed executing callback function.');
+    await getMessageBoxForErrors(
+      'Unexpected internal error',
+      '',
+      mainWindow,
+      true,
+    );
+  }
+}
+
+type FuncType<T> = T extends (...args: infer P) => infer R
+  ? (...args: P) => R
+  : never;
+
+type RemovePromise<A> = A extends Promise<infer B> ? B : A;
+type ReturnTypeWithoutPromise<A> =
+  A extends FuncType<A> ? RemovePromise<ReturnType<A>> : never;
+type FTParameters<A> = A extends FuncType<A> ? Parameters<A> : never;
+
+export function createVoidListenerCallbackWithErrorHandling<F>(
+  mainWindow: BrowserWindow,
+  func: F & FuncType<F>,
+): (...args: FTParameters<F>) => Promise<void> {
+  return async (...args: FTParameters<F>): Promise<void> => {
     try {
       await func(...args);
     } catch (error: unknown) {
-      if (error instanceof Error) {
-        logger.info(`Failed executing callback function: ${error.message}`);
-        await getMessageBoxForErrors(
-          error.message,
-          error.stack ?? '',
-          mainWindow,
-          true,
-        );
-      } else {
-        logger.info('Failed executing callback function.');
-        await getMessageBoxForErrors(
-          'Unexpected internal error',
-          '',
-          mainWindow,
-          true,
-        );
-      }
+      await reportListenerError(mainWindow, error);
+    }
+  };
+}
+
+export function createListenerCallbackWithErrorHandling<F>(
+  mainWindow: BrowserWindow,
+  func: F & FuncType<F>,
+): (...args: FTParameters<F>) => Promise<ReturnTypeWithoutPromise<F> | null> {
+  return async (
+    ...args: FTParameters<F>
+  ): Promise<ReturnTypeWithoutPromise<F> | null> => {
+    try {
+      return (await func(...args)) as ReturnTypeWithoutPromise<F>;
+    } catch (error: unknown) {
+      await reportListenerError(mainWindow, error);
+      return Promise.resolve(null);
     }
   };
 }