@sarafapp/iron_core 1.0.63 → 1.0.64

package/src/httpClient/HttpClient.ts

@@ -0,0 +1,77 @@
+import {
+  Axios,
+  AxiosHeaders,
+  type AxiosResponse,
+  type InternalAxiosRequestConfig,
+} from "axios";
+
+type axiosConfig = { headers?: AxiosHeaders } & Omit<
+  InternalAxiosRequestConfig,
+  "headers"
+>;
+
+export class HttpClient {
+  private axiosInstance: Axios;
+
+  constructor(instance: Axios) {
+    this.axiosInstance = instance;
+  }
+
+  public async get<T>(
+    url: string,
+    config?: axiosConfig,
+  ): Promise<AxiosResponse<T>> {
+    return await this.axiosInstance.get(
+      url,
+      config as InternalAxiosRequestConfig,
+    );
+  }
+
+  public async post<T>(
+    url: string,
+    data?: unknown,
+    config?: axiosConfig,
+  ): Promise<AxiosResponse<T>> {
+    return await this.axiosInstance.post(
+      url,
+      data,
+      config as InternalAxiosRequestConfig,
+    );
+  }
+
+  public async patch<T>(
+    url: string,
+    data?: unknown,
+    config?: axiosConfig,
+  ): Promise<AxiosResponse<T>> {
+    return await this.axiosInstance.patch(
+      url,
+      data,
+      config as InternalAxiosRequestConfig,
+    );
+  }
+
+  public async put<T>(
+    url: string,
+    data?: unknown,
+    config?: axiosConfig,
+  ): Promise<AxiosResponse<T>> {
+    return await this.axiosInstance.put(
+      url,
+      data,
+      config as InternalAxiosRequestConfig,
+    );
+  }
+
+  public async delete<T>(
+    url: string,
+    config?: axiosConfig,
+  ): Promise<AxiosResponse<T>> {
+    return await this.axiosInstance.delete(
+      url,
+      config as InternalAxiosRequestConfig,
+    );
+  }
+}
+
+export default HttpClient;

package/src/httpClient/Interceptor.ts

@@ -0,0 +1,5 @@
+import { type InternalAxiosRequestConfig } from "axios";
+
+export interface Interceptor {
+  intercept(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig;
+}

package/src/httpClient/index.ts

@@ -0,0 +1,4 @@
+export { APIErrorHandlerRegistry } from "./ErrorHandlerRegistry";
+export { ApiBuilder } from "./ApiBuilder";
+export { HttpClient } from "./HttpClient";
+export { type Interceptor } from './Interceptor';

package/src/initializer/ApplicationInitializer.ts

@@ -0,0 +1,15 @@
+import { type Initializer } from "./Initializer";
+
+export class ApplicationInitializer {
+    private _initializer: Initializer[] = [];
+
+    public setupInitializers(initializers: Initializer[]) {
+        this._initializer.push(...initializers);
+    }
+
+    public initialize() {
+        for (const initializer of this._initializer) {
+            initializer.initialize();
+        }
+    }
+}

package/src/initializer/Initializer.ts

@@ -0,0 +1,3 @@
+export interface Initializer {
+    initialize(): void
+}

package/src/initializer/index.ts

@@ -0,0 +1,2 @@
+export { ApplicationInitializer } from './ApplicationInitializer';
+export { type Initializer } from './Initializer';

package/src/json/JsonMapper.ts

@@ -0,0 +1,48 @@
+import type { Nullable } from "../types";
+import { JsonConvert } from "json2typescript";
+
+export class JsonMapper {
+  private static Instance: Nullable<JsonMapper> = null;
+  private jsonConverter = new JsonConvert();
+
+  private constructor() {}
+
+  public serializeObject<T extends object>(
+    object: object,
+    model: { new (): T },
+  ) {
+    return this.jsonConverter.serializeObject(object, model) as T;
+  }
+
+  public deserializeObject<T extends object>(
+    object: object,
+    model: { new (): T },
+  ) {
+    return this.jsonConverter.deserializeObject(object, model) as T;
+  }
+
+  public deserializeArray<T extends object>(
+    array: Array<T>,
+    model: { new (): T[] },
+  ) {
+    return this.jsonConverter.deserializeArray(array, model) as Array<T>;
+  }
+
+  public tryDeserialize(object: object, models: { new (): any }[]) {
+    for (const model of models) {
+      try {
+        return this.deserializeObject(object, model);
+      } catch (e) {
+        // ignore
+      }
+    }
+    throw new Error("Unable to deserialize object");
+  }
+
+  public static GetInstance() {
+    if (!JsonMapper.Instance) {
+      JsonMapper.Instance = new JsonMapper();
+    }
+    return JsonMapper.Instance;
+  }
+}

package/src/json/index.ts

@@ -0,0 +1 @@
+export { JsonMapper } from './JsonMapper';

package/src/layout/Constants.ts

@@ -0,0 +1,11 @@
+export const enum ToastType {
+    Success = 'success',
+    Failure = 'error',
+    Info = 'info',
+    Warning = 'warning',
+}
+
+export const enum ToastLocation {
+    BottomLeft = 'bottomLeft',
+    TopLeft = 'topLeft',
+}

package/src/layout/DialogService.ts

@@ -0,0 +1,75 @@
+import { type Component, computed, reactive } from 'vue';
+import { defineStore } from 'pinia';
+import { StoreNames, DialogDimensions } from '../constants';
+import { type Nullable } from '../types';
+
+export const useDialogService = defineStore(StoreNames.Dialog, () => {
+  const dialogData = reactive<{
+    dialogComponent: Nullable<Component>;
+    props: Nullable<Record<string, unknown>>;
+    header: string;
+    width: DialogDimensions;
+    height: DialogDimensions;
+  }>({
+    dialogComponent: null,
+    width: DialogDimensions.DefaultWidth,
+    height: DialogDimensions.DefaultHeight,
+    props: null,
+    header: '',
+  });
+
+  const isDialogExists = computed<boolean>(() => {
+    return Boolean(dialogData.dialogComponent);
+  });
+
+  const hasDefaultHeader = computed<boolean>(() => {
+    return Boolean(dialogData.header);
+  });
+
+  function openDialog(component: Component) {
+    dialogData.dialogComponent = component;
+  }
+
+  function setDialogHeader(header: string) {
+    dialogData.header = header;
+  }
+
+  function setProps(props: Record<string, unknown>) {
+    if (!isDialogExists.value) {
+      throw new Error('there is no dialog to set props on');
+    }
+    dialogData.props = props;
+  }
+
+  function setSize(size: number, type: DialogDimensions) {
+    if (!isDialogExists.value) {
+      throw new Error('there is no dialog to set size on');
+    }
+
+    if (size < DialogDimensions.MinimalAvailableSize) {
+      throw new Error('negative size not supported');
+    }
+
+    if (type === DialogDimensions.Width) dialogData.width = size;
+    else dialogData.height = size;
+  }
+
+  function clearDialog() {
+    dialogData.props = null;
+    dialogData.height = DialogDimensions.DefaultHeight;
+    dialogData.width = DialogDimensions.DefaultWidth;
+    dialogData.header = '';
+    dialogData.dialogComponent = null;
+  }
+
+  return {
+    dialogData,
+    openDialog,
+    clearDialog,
+    setSize,
+    setDialogHeader,
+    setProps,
+    isDialogExists,
+    hasDefaultHeader
+  };
+});

package/src/layout/DrawerService.ts

@@ -0,0 +1,25 @@
+import { computed, ref } from 'vue';
+import { defineStore } from 'pinia';
+import { StoreNames, ApplicationDrawerStatus } from '../constants';
+
+export const useDrawerService = defineStore(StoreNames.Drawer, () => {
+  const drawerStatus = ref<ApplicationDrawerStatus>(ApplicationDrawerStatus.Close);
+
+  const isDrawerOpen = computed<boolean>(() => {
+    return drawerStatus.value === ApplicationDrawerStatus.Open;
+  });
+
+  function closeDrawer() {
+    drawerStatus.value = ApplicationDrawerStatus.Close;
+  }
+
+  function openDrawer() {
+    drawerStatus.value = ApplicationDrawerStatus.Open;
+  }
+
+  return {
+    closeDrawer,
+    openDrawer,
+    isDrawerOpen,
+  };
+});

package/src/layout/Toast.ts

@@ -0,0 +1,14 @@
+import { ToastLocation, ToastType } from "./Constants";
+
+export class ToastMessage {
+  public type: ToastType;
+  public message: string;
+  public description: string;
+  public placement: ToastLocation = ToastLocation.BottomLeft;
+
+  constructor(type: ToastType, message: string, description: string) {
+    this.type = type;
+    this.message = message;
+    this.description = description;
+  }
+}

package/src/layout/index.ts

@@ -0,0 +1,4 @@
+export { ToastLocation, ToastType } from './Constants';
+export { ToastMessage } from './Toast';
+export { useDialogService } from './DialogService';
+export { useDrawerService } from './DrawerService';