stub of new error report data

src/utils/error-report/ErrorData.ts

+export type ErrorData = {
+  url: string | null;
+  login: string | null;
+  email: string | null;
+  browser: string | null;
+  timestamp: string | null;
+  version: string | null;
+  comment: string | null;
+  stacktrace: string;
+  javaStacktrace: string | null;
+};

src/utils/error-report/errorReporting.ts

+/* eslint-disable no-console */
+import { ErrorData } from '@/utils/error-report/ErrorData';
+import { SerializedError } from '@reduxjs/toolkit';
+
+export const handleError = (error: Error | SerializedError | undefined): void => {
+  let stacktrace = '';
+  if (error !== undefined) {
+    stacktrace = error.stack !== undefined ? error.stack : '';
+  }
+
+  const errorData: ErrorData = {
+    url: null, // TODO
+    login: null, // TODO provide user login
+    browser: null, // TODO
+    comment: null,
+    email: null, // TODO
+    javaStacktrace: null, // TODO
+    stacktrace,
+    timestamp: null, // TODO
+    version: null, // TODO
+  };
+  // eslint-disable-next-line no-console
+  console.log(errorData);
+};
+
+export const initializeErrorReporting = (): void => {
+  if (typeof window !== 'undefined') {
+    window.onerror = (msg, url, lineNo, columnNo, error): boolean => {
+      handleError(error);
+      return true;
+    };
+  }
+};

src/utils/error-report/getError.ts

+import { getErrorMessage } from '@/utils/getErrorMessage';
+import { SerializedError } from '@reduxjs/toolkit';
+import { getErrorName } from '@/utils/error-report/getErrorName';
+import { getErrorCode } from '@/utils/error-report/getErrorCode';
+import { getErrorStack } from '@/utils/error-report/getErrorStack';
+
+type GetErrorMessageConfig = {
+  error: unknown;
+  message?: string;
+  prefix?: string;
+};
+
+export const getError = ({ error, message, prefix }: GetErrorMessageConfig): SerializedError => {
+  const errorMessage = getErrorMessage({ error, message, prefix });
+
+  const name = getErrorName(error);
+  const stack = getErrorStack(error);
+  const code = getErrorCode(error);
+
+  return {
+    name,
+    message: errorMessage,
+    stack,
+    code,
+  };
+};

src/utils/error-report/getErrorCode.ts

+import axios from 'axios';
+import {
+  UNKNOWN_AXIOS_ERROR_CODE,
+  UNKNOWN_ERROR,
+} from '../getErrorMessage/getErrorMessage.constants';
+
+export const getErrorCode = (error: unknown): string => {
+  if (axios.isAxiosError(error)) {
+    const { code } = error;
+    return code || UNKNOWN_AXIOS_ERROR_CODE;
+  }
+  return UNKNOWN_ERROR;
+};

src/utils/error-report/getErrorName.ts

+import axios from 'axios';
+import { UNKNOWN_ERROR } from '../getErrorMessage/getErrorMessage.constants';
+
+export const getErrorName = (error: unknown): string => {
+  if (axios.isAxiosError(error)) {
+    return error.name;
+  }
+  if (error instanceof Error) {
+    return error.name;
+  }
+  return UNKNOWN_ERROR;
+};

src/utils/error-report/getErrorStack.ts

+import axios from 'axios';
+import { getErrorUrl } from '@/utils/error-report/getErrorUrl';
+
+export const getErrorStack = (error: unknown): string => {
+  let stack = null;
+  if (axios.isAxiosError(error)) {
+    const url = getErrorUrl(error);
+
+    stack = (url ? `(Request URL: ${url}) ` : '') + error.stack;
+  } else if (error instanceof Error) {
+    stack = error.stack;
+  }
+  return stack || 'No stack provided';
+};

src/utils/error-report/getErrorUrl.ts

+import axios from 'axios';
+
+export const getErrorUrl = (error: unknown): string | null => {
+  if (axios.isAxiosError(error)) {
+    if (error.request) {
+      if (error.request.responseURL) {
+        return error.request.responseURL;
+      }
+    }
+  }
+  return null;
+};

src/utils/getErrorMessage/getErrorMessage.constants.ts

 export const UNKNOWN_ERROR = 'An unknown error occurred. Please try again later.';
+export const UNKNOWN_AXIOS_ERROR_CODE = 'UNKNOWN_AXIOS_ERROR';
 
 export const HTTP_ERROR_MESSAGES = {
   400: "The server couldn't understand your request. Please check your input and try again.",