@povio/ui 0.0.5 → 0.0.6

package/{src/utils/date-time.utils.ts → dist/utils/date-time.utils.js}

@@ -1,57 +1,48 @@
-import {
-  CalendarDate,
-  CalendarDateTime,
-  type DateValue,
-  type ZonedDateTime,
-  fromDate,
-  getLocalTimeZone,
-  parseAbsolute,
-  parseAbsoluteToLocal,
-} from "@internationalized/date";
+import { parseAbsoluteToLocal, getLocalTimeZone, fromDate, CalendarDate, parseAbsolute, CalendarDateTime } from "@internationalized/date";
 import { DateTime } from "luxon";
-
-export namespace DateTimeUtils {
-  export function fromISOtoZonedDateTime(isoString: string): ZonedDateTime {
+var DateTimeUtils;
+((DateTimeUtils2) => {
+  function fromISOtoZonedDateTime(isoString) {
     return parseAbsoluteToLocal(isoString);
   }
-
-  export function fromDateValueToISO(dateValue: DateValue): string {
+  DateTimeUtils2.fromISOtoZonedDateTime = fromISOtoZonedDateTime;
+  function fromDateValueToISO(dateValue) {
     return dateValue.toDate(getLocalTimeZone()).toISOString();
   }
-
-  export function fromLocalToZonedDateTime(date: Date): ZonedDateTime {
+  DateTimeUtils2.fromDateValueToISO = fromDateValueToISO;
+  function fromLocalToZonedDateTime(date) {
     return fromDate(date, getLocalTimeZone());
   }
-
-  export function fromDateValueToLocal(dateValue: DateValue): Date {
+  DateTimeUtils2.fromLocalToZonedDateTime = fromLocalToZonedDateTime;
+  function fromDateValueToLocal(dateValue) {
     return dateValue.toDate(getLocalTimeZone());
   }
-
-  export function fromCalendarDateToUTCISO(calendarDate: CalendarDate, options: { endOfDay?: boolean } = {}): string {
+  DateTimeUtils2.fromDateValueToLocal = fromDateValueToLocal;
+  function fromCalendarDateToUTCISO(calendarDate, options = {}) {
     const date = DateTime.fromObject(
       {
         year: calendarDate.year,
         month: calendarDate.month,
-        day: calendarDate.day,
+        day: calendarDate.day
       },
-      { zone: "utc" },
+      { zone: "utc" }
     );
     if (options.endOfDay) {
       return date.endOf("day").toUTC().toISO() ?? calendarDate.toString();
     }
     return date.toUTC().toISO() ?? calendarDate.toString();
   }
-
-  export function fromUTCISOToCalendarDate(isoString: string): CalendarDate {
+  DateTimeUtils2.fromCalendarDateToUTCISO = fromCalendarDateToUTCISO;
+  function fromUTCISOToCalendarDate(isoString) {
     const date = new Date(isoString);
     return new CalendarDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
   }
-
-  export function fromCalendarDateTimeToUTCISO(calendarDateTime: CalendarDateTime): string {
+  DateTimeUtils2.fromUTCISOToCalendarDate = fromUTCISOToCalendarDate;
+  function fromCalendarDateTimeToUTCISO(calendarDateTime) {
     return calendarDateTime.toDate("UTC").toISOString();
   }
-
-  export function fromUTCISOToCalendarDateTime(isoString: string): CalendarDateTime {
+  DateTimeUtils2.fromCalendarDateTimeToUTCISO = fromCalendarDateTimeToUTCISO;
+  function fromUTCISOToCalendarDateTime(isoString) {
     const zonedDateTime = parseAbsolute(isoString, "UTC");
     return new CalendarDateTime(
       zonedDateTime.year,
@@ -60,26 +51,27 @@ export namespace DateTimeUtils {
       zonedDateTime.hour,
       zonedDateTime.minute,
       zonedDateTime.second,
-      zonedDateTime.millisecond,
+      zonedDateTime.millisecond
     );
   }
-
-  export function formatTextDateToCalendarDateTime(textDate: string | null): CalendarDateTime | null {
+  DateTimeUtils2.fromUTCISOToCalendarDateTime = fromUTCISOToCalendarDateTime;
+  function formatTextDateToCalendarDateTime(textDate) {
     if (!textDate?.includes("hh")) {
       return null;
     }
-
     const datePart = textDate.split(",").at(0)?.trim();
     if (!datePart) {
       return null;
     }
-
     const date = new Date(datePart);
     if (!date || date.toString() === "Invalid Date") {
       return null;
     }
-
     const zonedDateTime = fromDate(date, getLocalTimeZone());
     return new CalendarDateTime(zonedDateTime.year, zonedDateTime.month, zonedDateTime.day, 0, 0, 0, 0);
   }
-}
+  DateTimeUtils2.formatTextDateToCalendarDateTime = formatTextDateToCalendarDateTime;
+})(DateTimeUtils || (DateTimeUtils = {}));
+export {
+  DateTimeUtils
+};

package/dist/utils/date-time.utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/date.utils.d.ts

@@ -0,0 +1,3 @@
+export declare namespace DateUtils {
+    function formatDate(date: Date, format?: string): string;
+}

package/dist/utils/date.utils.js

@@ -0,0 +1,12 @@
+import { DateTime } from "luxon";
+var DateUtils;
+((DateUtils2) => {
+  const DATE_FORMAT = "dd/MM/yyyy";
+  function formatDate(date, format = DATE_FORMAT) {
+    return DateTime.fromJSDate(date).toFormat(format);
+  }
+  DateUtils2.formatDate = formatDate;
+})(DateUtils || (DateUtils = {}));
+export {
+  DateUtils
+};

package/dist/utils/date.utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/dom.utils.d.ts

@@ -0,0 +1,5 @@
+import { KeyboardEvent, SyntheticEvent } from 'react';
+export declare namespace DomUtils {
+    const isKeyboardInput: (elem: Element) => boolean;
+    const isKeyboardEvent: (event: SyntheticEvent) => event is KeyboardEvent;
+}

package/dist/utils/dom.utils.js

@@ -0,0 +1,13 @@
+var DomUtils;
+((DomUtils2) => {
+  const KEYBOARD_INPUTS = ["button", "submit", "checkbox", "file", "image"];
+  DomUtils2.isKeyboardInput = (elem) => {
+    return elem.tagName === "INPUT" && !KEYBOARD_INPUTS.includes(elem.type) || elem.hasAttribute("contenteditable");
+  };
+  DomUtils2.isKeyboardEvent = (event) => {
+    return event.nativeEvent instanceof KeyboardEvent;
+  };
+})(DomUtils || (DomUtils = {}));
+export {
+  DomUtils
+};

package/dist/utils/file.utils.d.ts

@@ -0,0 +1,9 @@
+import { AxiosResponse } from 'axios';
+export declare namespace FileUtils {
+    const getObjectUrl: (data: Blob | AxiosResponse<Blob>, revokeTimeoutMs?: number) => string;
+    const openFile: (data: Blob | AxiosResponse<Blob>, target?: string, revokeTimeoutMs?: number) => void;
+    const downloadFile: (data: Blob | AxiosResponse<Blob>, fileName?: string, revokeTimeoutMs?: number) => void;
+    const isFileTypeAccepted: (file: File, fileTypes?: readonly string[] | string[]) => boolean;
+    const getCalculatedFileSize: (file?: File) => string;
+    const formatBytes: (size: number, decimals?: number) => string;
+}

package/{src/utils/file.utils.ts → dist/utils/file.utils.js}

@@ -1,48 +1,36 @@
-import type { AxiosResponse, AxiosResponseHeaders } from "axios";
-
-import { RestUtils } from "#ui/utils/rest/rest.utils";
-
-export namespace FileUtils {
-  export const getObjectUrl = (data: Blob | AxiosResponse<Blob>, revokeTimeoutMs = 40_000) => {
+import { RestUtils } from "./rest/rest.utils.js";
+var FileUtils;
+((FileUtils2) => {
+  FileUtils2.getObjectUrl = (data, revokeTimeoutMs = 4e4) => {
     const url = URL.createObjectURL(data instanceof Blob ? data : data.data);
     setTimeout(() => URL.revokeObjectURL(url), revokeTimeoutMs);
     return url;
   };
-
-  export const openFile = (data: Blob | AxiosResponse<Blob>, target = "_blank", revokeTimeoutMs?: number) => {
-    const url = getObjectUrl(data, revokeTimeoutMs);
+  FileUtils2.openFile = (data, target = "_blank", revokeTimeoutMs) => {
+    const url = (0, FileUtils2.getObjectUrl)(data, revokeTimeoutMs);
     window.open(url, target);
   };
-
-  export const downloadFile = (data: Blob | AxiosResponse<Blob>, fileName?: string, revokeTimeoutMs?: number) => {
-    const url = getObjectUrl(data, revokeTimeoutMs);
-    const contentDispositionFileName =
-      data instanceof Blob
-        ? undefined
-        : RestUtils.extractContentDispositionFilename(data.headers as AxiosResponseHeaders);
-
+  FileUtils2.downloadFile = (data, fileName, revokeTimeoutMs) => {
+    const url = (0, FileUtils2.getObjectUrl)(data, revokeTimeoutMs);
+    const contentDispositionFileName = data instanceof Blob ? void 0 : RestUtils.extractContentDispositionFilename(data.headers);
     const a = document.createElement("a");
     a.download = fileName ?? contentDispositionFileName ?? "download";
     a.rel = "noopener";
     a.href = url;
-
     setTimeout(() => a.dispatchEvent(new MouseEvent("click")));
   };
-
-  export const isFileTypeAccepted = (file: File, fileTypes?: readonly string[] | string[]): boolean => {
+  FileUtils2.isFileTypeAccepted = (file, fileTypes) => {
     if (!fileTypes || fileTypes.length === 0) {
       return true;
     }
-
     return fileTypes.some((type) => {
       if (type.includes("/")) {
-        return file.type === type || (type.endsWith("/*") && file.type.startsWith(type.slice(0, -1)));
+        return file.type === type || type.endsWith("/*") && file.type.startsWith(type.slice(0, -1));
       }
       return file.name.toLowerCase().endsWith(type.toLowerCase());
     });
   };
-
-  export const getCalculatedFileSize = (file?: File): string => {
+  FileUtils2.getCalculatedFileSize = (file) => {
     if (!file) {
       return "";
     }
@@ -57,8 +45,7 @@ export namespace FileUtils {
     }
     return `${(file.size / 1024 / 1024 / 1024).toFixed(2)} GB`;
   };
-
-  export const formatBytes = (size: number, decimals = 2) => {
+  FileUtils2.formatBytes = (size, decimals = 2) => {
     if (size < 1024) {
       return `${size} B`;
     }
@@ -70,4 +57,7 @@ export namespace FileUtils {
     }
     return `${(size / 1024 / 1024 / 1024).toFixed(decimals)} GB`;
   };
-}
+})(FileUtils || (FileUtils = {}));
+export {
+  FileUtils
+};

package/dist/utils/isEqual.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: (a: any, b: any) => boolean;

package/dist/utils/isEqual.js

@@ -0,0 +1,94 @@
+import { ObjectUtils } from "./object.utils.js";
+const isEqual = (a, b) => {
+  return eq(a, b);
+};
+const eq = (a, b, aStack, bStack) => {
+  if (a === b) {
+    return a !== 0 || 1 / a === 1 / b;
+  }
+  if (a == null || b == null) {
+    return a === b;
+  }
+  if (a !== a) {
+    return b !== b;
+  }
+  const type = typeof a;
+  if (type !== "function" && type !== "object" && typeof b !== "object") {
+    return false;
+  }
+  return deepEq(a, b, aStack, bStack);
+};
+const deepEq = (a, b, aStack, bStack) => {
+  const className = toString.call(a);
+  if (className !== toString.call(b)) {
+    return false;
+  }
+  switch (className) {
+    // Strings, numbers, regular expressions, dates, and booleans are compared by value.
+    // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
+    case "[object RegExp]":
+    case "[object String]":
+      return `${a}` === `${b}`;
+    case "[object Number]":
+      if (+a !== +a) {
+        return +b !== +b;
+      }
+      return +a === 0 ? 1 / +a === 1 / b : +a === +b;
+    case "[object Date]":
+    case "[object Boolean]":
+      return +a === +b;
+    case "[object Symbol]":
+      return Symbol.prototype.valueOf.call(a) === Symbol.prototype.valueOf.call(b);
+  }
+  const areArrays = className === "[object Array]";
+  if (!areArrays) {
+    if (typeof a !== "object" || typeof b !== "object") {
+      return false;
+    }
+    const aCtor = a.constructor;
+    const bCtor = b.constructor;
+    if (aCtor !== bCtor && !(ObjectUtils.isFunction(aCtor) && aCtor instanceof aCtor && ObjectUtils.isFunction(bCtor) && bCtor instanceof bCtor) && "constructor" in a && "constructor" in b) {
+      return false;
+    }
+  }
+  aStack = aStack || [];
+  bStack = bStack || [];
+  let { length } = aStack;
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  if (areArrays) {
+    length = a.length;
+    if (length !== b.length) {
+      return false;
+    }
+    while (length--) {
+      if (!eq(a[length], b[length], aStack, bStack)) {
+        return false;
+      }
+    }
+  } else {
+    const keys = Object.keys(a);
+    let key;
+    length = keys.length;
+    if (Object.keys(b).length !== length) {
+      return false;
+    }
+    while (length--) {
+      key = keys[length];
+      if (!(Object.prototype.hasOwnProperty.call(b, key) && eq(a[key], b[key], aStack, bStack))) {
+        return false;
+      }
+    }
+  }
+  aStack.pop();
+  bStack.pop();
+  return true;
+};
+export {
+  isEqual
+};

package/dist/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+import log from "loglevel";
+import prefix from "loglevel-plugin-prefix";
+prefix.reg(log);
+prefix.apply(log, {
+  template: "[%t] %l:",
+  timestampFormatter: (date) => {
+    return date.toISOString();
+  }
+});
+const logger = {
+  info: (...args) => log.info(...args),
+  debug: (...args) => log.debug(...args),
+  warn: (...args) => log.warn(...args),
+  error: (...args) => log.error(...args),
+  trace: (...args) => log.trace(...args)
+};
+export {
+  logger
+};

package/dist/utils/object.utils.d.ts

@@ -0,0 +1,10 @@
+export declare namespace ObjectUtils {
+    const isNil: (obj: unknown) => obj is null | undefined;
+    const isFunction: (obj: unknown) => obj is Function;
+    const isObject: (obj: unknown) => obj is object;
+    const isString: (obj: unknown) => obj is string;
+    const isDate: (obj: unknown) => obj is Date;
+    const isRegExp: (obj: unknown) => obj is RegExp;
+    const isEmpty: (obj: unknown) => boolean;
+    const deepConditionalMerge: <T extends object>(target: Partial<T>, source: Partial<T>, condition: (value: unknown, key: string) => boolean) => T;
+}

package/dist/utils/object.utils.js

@@ -0,0 +1,53 @@
+var ObjectUtils;
+((ObjectUtils2) => {
+  ObjectUtils2.isNil = (obj) => {
+    return obj == null;
+  };
+  ObjectUtils2.isFunction = (obj) => {
+    return typeof obj === "function";
+  };
+  ObjectUtils2.isObject = (obj) => {
+    return typeof obj === "object" && !!obj;
+  };
+  ObjectUtils2.isString = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object String]";
+  };
+  ObjectUtils2.isDate = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object Date]";
+  };
+  ObjectUtils2.isRegExp = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object RegExp]";
+  };
+  ObjectUtils2.isEmpty = (obj) => {
+    if (obj == null) {
+      return true;
+    }
+    if (Array.isArray(obj) || (0, ObjectUtils2.isString)(obj)) {
+      return obj.length === 0;
+    }
+    return Object.keys(obj).length === 0;
+  };
+  ObjectUtils2.deepConditionalMerge = (target, source, condition) => {
+    const output = { ...target };
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const value = source[key];
+        if (condition(value, key)) {
+          if (typeof value === "object" && !Array.isArray(value)) {
+            output[key] = (0, ObjectUtils2.deepConditionalMerge)(
+              output[key],
+              value,
+              condition
+            );
+          } else {
+            output[key] = value;
+          }
+        }
+      }
+    }
+    return output;
+  };
+})(ObjectUtils || (ObjectUtils = {}));
+export {
+  ObjectUtils
+};

package/dist/utils/queries.utils.d.ts

@@ -0,0 +1,4 @@
+import { QueryClient } from '@tanstack/react-query';
+export declare namespace QueriesUtils {
+    const prefetchMultipleQueries: (queryClient: QueryClient, queries: Array<(queryClient: QueryClient) => Promise<void>>) => Promise<void[]>;
+}

package/dist/utils/queries.utils.js

@@ -0,0 +1,9 @@
+var QueriesUtils;
+((QueriesUtils2) => {
+  QueriesUtils2.prefetchMultipleQueries = (queryClient, queries) => {
+    return Promise.all(queries.map((query) => query(queryClient)));
+  };
+})(QueriesUtils || (QueriesUtils = {}));
+export {
+  QueriesUtils
+};

package/dist/utils/rest/interceptors/logging.interceptor.d.ts

@@ -0,0 +1,2 @@
+import { RestInterceptor } from './rest-interceptor';
+export declare const LoggingInterceptor: RestInterceptor<[]>;

package/dist/utils/rest/interceptors/logging.interceptor.js

@@ -0,0 +1,17 @@
+import { logger } from "../../logger.js";
+import { RestInterceptor } from "./rest-interceptor.js";
+const LoggingInterceptor = new RestInterceptor((client) => {
+  return client.interceptors.request.use(
+    (config) => {
+      logger.info("Rest call", config.method, config.url, config.data);
+      return config;
+    },
+    (error) => {
+      logger.error("Rest call error", error);
+      return Promise.reject(error);
+    }
+  );
+});
+export {
+  LoggingInterceptor
+};

package/dist/utils/rest/interceptors/response.interceptor.d.ts

@@ -0,0 +1,2 @@
+import { RestInterceptor } from './rest-interceptor';
+export declare const ResponseInterceptor: RestInterceptor<[]>;

package/{src/utils/rest/interceptors/response.interceptor.ts → dist/utils/rest/interceptors/response.interceptor.js}

@@ -1,27 +1,25 @@
-import type { AxiosError } from "axios";
-
-import { logger } from "#ui/utils/logger";
-
-import { RestInterceptor } from "./rest-interceptor";
-
-export const ResponseInterceptor = new RestInterceptor((client) => {
+import { logger } from "../../logger.js";
+import { RestInterceptor } from "./rest-interceptor.js";
+const ResponseInterceptor = new RestInterceptor((client) => {
   return client.interceptors.response.use(
     (response) => {
       logger.info("Rest response", response.data, response?.config?.url, response?.status);
-
       return {
         ...response,
         // oxlint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        data: response.data === "" ? undefined : response.data,
+        data: response.data === "" ? void 0 : response.data
       };
     },
-    (error: AxiosError) => {
+    (error) => {
       logger.error(
         `Rest response error: ${error?.response?.config?.url}`,
         error?.response?.data,
-        error?.response?.status,
+        error?.response?.status
       );
       throw error;
-    },
+    }
   );
 });
+export {
+  ResponseInterceptor
+};

package/dist/utils/rest/interceptors/rest-interceptor.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+export declare class RestInterceptor<T extends any[]> {
+    private applyInterceptor;
+    private interceptorIdMap;
+    constructor(applyInterceptor: (client: AxiosInstance, ...args: T) => number);
+    addInterceptor(client: AxiosInstance, ...args: T): void;
+    removeInterceptor(client: AxiosInstance): void;
+}

package/{src/utils/rest/interceptors/rest-interceptor.ts → dist/utils/rest/interceptors/rest-interceptor.js}

@@ -1,22 +1,21 @@
-import type { AxiosInstance } from "axios";
-
-export class RestInterceptor<T extends any[]> {
-  private interceptorIdMap: { client: AxiosInstance; interceptorId: number }[] = [];
-
-  constructor(private applyInterceptor: (client: AxiosInstance, ...args: T) => number) {}
-
-  public addInterceptor(client: AxiosInstance, ...args: T) {
+class RestInterceptor {
+  constructor(applyInterceptor) {
+    this.applyInterceptor = applyInterceptor;
+    this.interceptorIdMap = [];
+  }
+  addInterceptor(client, ...args) {
     this.removeInterceptor(client);
     const interceptorId = this.applyInterceptor(client, ...args);
     this.interceptorIdMap.push({ client, interceptorId });
   }
-
-  public removeInterceptor(client: AxiosInstance) {
+  removeInterceptor(client) {
     const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
-
     if (interceptorId != null) {
       client.interceptors.request.eject(interceptorId);
       this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
     }
   }
 }
+export {
+  RestInterceptor
+};

package/dist/utils/rest/rest-client.d.ts

@@ -0,0 +1,29 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, CreateAxiosDefaults } from 'axios';
+import { z } from 'zod';
+import { RestInterceptor } from '#ui/utils/rest/interceptors/rest-interceptor';
+import { ErrorHandler, GeneralErrorCodes } from '#ui/utils/vendor/error-handling';
+interface RequestInfo<ZOutput, ECodes extends string> {
+    resSchema: z.ZodType<ZOutput>;
+    errorHandler?: ErrorHandler<ECodes>;
+}
+interface RequestConfig<IsRawRes extends boolean = false> {
+    rawResponse?: IsRawRes;
+}
+type Response<ZOutput, IsRawRes extends boolean = false> = IsRawRes extends true ? AxiosResponse<ZOutput> : ZOutput;
+export declare class RestClient {
+    protected client: AxiosInstance;
+    constructor({ config, interceptors, }?: {
+        config?: CreateAxiosDefaults;
+        interceptors?: RestInterceptor<any[]>[];
+    });
+    attachInterceptors<T extends any[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+    attachInterceptor<T extends any[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+    ejectInterceptor<T extends any[]>(interceptor: RestInterceptor<T>): void;
+    get<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    post<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    patch<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    put<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    delete<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    private makeRequest;
+}
+export {};

package/dist/utils/rest/rest-client.js

@@ -0,0 +1,62 @@
+import axios from "axios";
+import { z } from "zod";
+import { LoggingInterceptor } from "./interceptors/logging.interceptor.js";
+import { ResponseInterceptor } from "./interceptors/response.interceptor.js";
+import { SharedErrorHandler } from "../vendor/error-handling.js";
+class RestClient {
+  constructor({
+    config,
+    interceptors
+  } = {}) {
+    this.client = axios.create(config);
+    const defaultInterceptors = [LoggingInterceptor, ResponseInterceptor];
+    this.attachInterceptors(defaultInterceptors);
+    this.attachInterceptors(interceptors);
+  }
+  attachInterceptors(interceptors, ...args) {
+    if (interceptors != null) {
+      interceptors.forEach((interceptor) => this.attachInterceptor(interceptor, ...args));
+    }
+  }
+  attachInterceptor(interceptor, ...args) {
+    interceptor.addInterceptor(this.client, ...args);
+  }
+  ejectInterceptor(interceptor) {
+    interceptor.removeInterceptor(this.client);
+  }
+  async get(requestInfo, url, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "get", url });
+  }
+  async post(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "post", url, data });
+  }
+  async patch(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "patch", url, data });
+  }
+  async put(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "put", url, data });
+  }
+  async delete(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "delete", url, data });
+  }
+  async makeRequest(requestInfo, requestConfig) {
+    const errorStack = new Error().stack;
+    try {
+      const { rawResponse, ...config } = requestConfig;
+      const res = await this.client(config);
+      const resData = requestInfo.resSchema.parse(res.data);
+      return rawResponse ? { ...res, data: resData } : resData;
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        e.name = "BE Response schema mismatch - ZodError";
+        e.stack = [e.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+      }
+      const errorHandler = requestInfo.errorHandler ?? SharedErrorHandler;
+      errorHandler.rethrowError(e);
+      throw e;
+    }
+  }
+}
+export {
+  RestClient
+};