nexus-shared 1.1.18 → 1.1.20

package/src/helpers/validation-helpers.tsx

@@ -0,0 +1,302 @@
+import { EInputTypes, ICheckbox, IDate, IInputCreateResults, IInputParameters, IInputRootParameters, INumber, ISelection, ITablularForm, ITextbox, RegexTypes, UN } from "../interface";
+import { BitwiseToList } from "./bitwise-helpers";
+import { GetInputId } from "./input-helpers";
+import { IsNullOrEmpty, MakeFirstLetterUpperCase } from "./string-helpers";
+
+export const MAX_INPUT_TYPE = 1900;
+export const MAX_HINT_LENGTH = 5;
+
+export const IsValidInputs = (inputObjects: IInputCreateResults[] | UN, inputFormValues: any, isAutoError: boolean, isAutoFocus: boolean): boolean => {
+  let isValid = true;
+  if (!inputObjects || inputObjects.length === 0) return true;
+  const sortedObjects = [...inputObjects].sort((a, b) => b.input.displayOrder - a.input.displayOrder);
+  for (const obj of sortedObjects) {
+    // Skip unsupported input types
+    if (obj.input.inputType >= MAX_INPUT_TYPE) continue;
+
+    const inputId = GetInputId(obj.input);
+    const inputValue = inputFormValues?.[inputId] ?? null;
+    const isValidInput = IsValidInput(obj, inputValue, isAutoError, isAutoFocus);
+    if (isValid) isValid = isValidInput;
+  }
+  return isValid;
+};
+
+export const IsValidInput = (inputObject: IInputCreateResults, inputValue: any, isAutoError: boolean, isAutoFocus: boolean): boolean => {
+  const input = inputObject.inputElement;
+  const inputParameters = inputObject.input;
+  const value = inputValue;
+
+  switch (inputParameters.inputType) {
+    //---------------------
+    case EInputTypes.Textbox:
+    case EInputTypes.Textarea:
+    case EInputTypes.Texteditor:
+      return IsValidTextbox(inputParameters as ITextbox, value, isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.Checkbox:
+      return IsValidCheck(inputParameters as ICheckbox, value as boolean, isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.MultiSelection:
+    case EInputTypes.SingleSelection:
+      return IsValidSelectionbox(inputParameters as ISelection, value, isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.Datepicker:
+      return IsValidDate(inputParameters as IDate, value as Date | UN, isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.Number:
+      return IsValidNumber(inputParameters as INumber, value as number | UN, isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.TabularForm:
+      return IsValidTabularform(inputParameters as ITablularForm, value as any[], isAutoFocus, isAutoError, input);
+    //---------------------
+    case EInputTypes.Radiobox:
+      return true;
+
+    default:
+      return false;
+  }
+};
+
+// ------------- Start Textbox Validation -------------
+function IsValidTextbox<T>(inputParameters: ITextbox, value: T | UN, isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN): boolean {
+  if (!inputParameters) return false;
+  return IsValidInputValueWithRegex(inputParameters, input, inputParameters.validatorKey, value as string | UN, inputParameters.minLength ?? 0, inputParameters.maxLength ?? 0, isAutoError, isNeedFocus, inputParameters.regexKey).isValid;
+}
+export function IsValidInputValueWithRegex(inputParameters: ITextbox, input: HTMLElement | UN, key: string | UN, value: string | UN, min: number, max: number, isAutoError: boolean = true, isNeedFocus: boolean, regularExpression: RegexTypes | UN): IValidationMessage {
+  const valid = IsValidInputValueWithLength(inputParameters, input, key, value, min, max, false, isNeedFocus);
+  if (Array.isArray(regularExpression)) {
+    if (IsNullOrEmpty(value)) return { isValid: false, message: InvalidValueMessage(key) };
+
+    const isMatch = regularExpression.includes(value as string);
+    const msg = !isMatch ? `${InvalidValueMessage(key)}\nOnly allowed values are: ${MakeFirstLetterUpperCase(regularExpression.slice(0, MAX_HINT_LENGTH).join(", "))}${regularExpression.length > MAX_HINT_LENGTH ? `...` : "."}` : null;
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, !isMatch, msg, isNeedFocus);
+
+    return { isValid: isMatch, message: msg };
+  } else if (typeof regularExpression === "string") {
+    const isMatch = IsMatchRejex(value, regularExpression);
+    if (!isMatch) {
+      const msg = InvalidValueMessage(key ?? "Input-Value");
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, msg, isNeedFocus);
+      return { isValid: isMatch, message: msg };
+    }
+  }
+
+  if (!valid.isValid) {
+    AddRemoveErrorFromInput(inputParameters, input, isAutoError, valid.message, isNeedFocus);
+    return valid;
+  }
+
+  if (regularExpression && (regularExpression as string) !== "") {
+    const isMatch = IsMatchRejex(value, regularExpression);
+    if (!isMatch) {
+      const msg = InvalidValueMessage(key ?? "Input-Value");
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, msg, isNeedFocus);
+      return { isValid: isMatch, message: msg };
+    }
+  }
+  if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false);
+  return { isValid: true, message: "Valid" };
+}
+export function IsValidInputValueWithLength(inputParameters: IInputParameters<any>, input: HTMLElement | UN, key: string | UN, value: string | UN, min: number, max: number, isAutoError: boolean = true, isNeedFocus: boolean): IValidationMessage {
+  if (IsNullOrEmpty(value) && min > 0) {
+    const mes = RequiredMessage(key);
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, mes, isNeedFocus);
+    return { isValid: false, message: mes };
+  }
+  value = value ?? "";
+  if (min > 0 && value.length < min) {
+    const mes = MinLengthNotValidMessage(key ?? "Input-Value", min, false);
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, mes, isNeedFocus);
+    return { isValid: false, message: mes };
+  } else if (max > 0 && value.length > max) {
+    const mes = MaxLengthNotValidMessage(key ?? "Input-Value", max, false);
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, mes, isNeedFocus);
+    return { isValid: false, message: mes };
+  }
+  if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false);
+  return { isValid: true, message: "Valid" };
+}
+// ------------- End Textbox Validation -------------
+
+// ------------- Start Checkbox Validation -------------
+function IsValidCheck(inputParameters: ICheckbox, value: boolean, isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN): boolean {
+  if (!inputParameters) return false;
+  if (!value) {
+    if (inputParameters.isRequired) {
+      const requiredMessage = RequiredMessage(inputParameters.validatorKey);
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, requiredMessage, isNeedFocus);
+      return false;
+    } else {
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false, undefined, isNeedFocus);
+      return true;
+    }
+  }
+
+  if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false, undefined, isNeedFocus);
+  return true;
+}
+// ------------- End Checkbox Validation -------------
+
+// ------------- Start Selectionbox Validation -------------
+function IsValidSelectionbox(inputParameters: ISelection, value: any | UN, isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN): boolean {
+  let isValid = true;
+  const isMulti = inputParameters.inputType === EInputTypes.MultiSelection;
+  if (!inputParameters) isValid = false;
+  else if (!inputParameters.isRequired) isValid = true;
+  else isValid = isMulti ? value?.length > 0 : value !== null;
+
+  if (!isValid && isMulti && inputParameters.bitwiseEnum !== undefined && inputParameters.bitwiseEnum !== null) isValid = BitwiseToList(inputParameters.bitwiseEnum, value).length > 0;
+
+  if (isValid) {
+    AddRemoveErrorFromInput(inputParameters, input, false);
+    return isValid;
+  }
+
+  const msg = RequiredMessage(inputParameters.validatorKey ?? "Input-Value");
+  if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, msg, isNeedFocus);
+  return isValid;
+}
+// ------------- End Selectionbox Validation -------------
+
+// ------------- Start Date Validation -------------
+function IsValidDate(inputParameters: IDate, value: Date | UN, isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN): boolean {
+  if (!inputParameters) return false;
+  return false;
+}
+// ------------- End Date Validation -------------
+
+// ------------- Start Number Validation -------------
+function IsValidNumber(inputParameters: INumber, value: number | UN, isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN): boolean {
+  if (!inputParameters) return false;
+  if (value === null || value === undefined) {
+    if (inputParameters.isRequired) {
+      const requiredMessage = RequiredMessage(inputParameters.validatorKey);
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, requiredMessage, isNeedFocus);
+      return false;
+    } else {
+      if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false, undefined, isNeedFocus);
+      return true;
+    }
+  }
+
+  if (inputParameters.minLength !== undefined && inputParameters.minLength !== null && value < inputParameters.minLength) {
+    const msg = MinLengthNotValidMessage(inputParameters.validatorKey ?? "Input", inputParameters.minLength, false);
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, msg, isNeedFocus);
+    return false;
+  } else if (inputParameters.maxLength !== undefined && inputParameters.maxLength !== null && value > inputParameters.maxLength) {
+    const msg = MaxLengthNotValidMessage(inputParameters.validatorKey ?? "Input", inputParameters.maxLength, false);
+    if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, true, msg, isNeedFocus);
+    return false;
+  }
+
+  if (isAutoError) AddRemoveErrorFromInput(inputParameters, input, false, undefined, isNeedFocus);
+  return true;
+}
+// ------------- End Number Validation -------------
+
+// ------------- Start Tabularform Validation -------------
+function IsValidTabularform(inputParameters: ITablularForm, value: any[], isNeedFocus: boolean, isAutoError: boolean, input: HTMLElement | UN) {
+  return false;
+}
+// ------------- End Tabularform Validation -------------
+
+// ------------- Starting Input Error Handling -------------
+export const AddRemoveErrorFromInput = (inputParameters: IInputRootParameters<any>, input: HTMLElement | UN, isShowError: boolean, errorMessage?: string | UN, isNeedFocus?: boolean) => {
+  if (!input) return;
+  const formGroup = input.parentElement;
+  if (!formGroup) return;
+
+  const errorMessageTitle_Class = "input-error-message-popup";
+  if ((formGroup as any).cleanup) (formGroup as any).cleanup();
+  const formWrapper = formGroup.parentElement;
+  if (isShowError) {
+    formGroup.classList.add("error");
+    const errorMessageTitle = GetValidationMessage(inputParameters);
+    //const errorMessageBox = CreateTitle(errorMessageTitle, formGroup);
+    //errorMessageBox.titleElement.classList.add(errorMessageTitle_Class);
+    if (formWrapper && formWrapper.classList.contains("ipt-wp")) ShowError(input, formWrapper, errorMessage, isNeedFocus);
+    else if (formGroup.classList.contains("ipt-wp")) ShowError(input, formGroup, errorMessage, isNeedFocus);
+  } else {
+    formGroup.classList.remove("error");
+    if (formWrapper && formWrapper.classList.contains("ipt-wp")) formWrapper.querySelector(".msg")?.remove();
+    else if (formGroup.classList.contains("ipt-wp")) formGroup.querySelector(".msg")?.remove();
+  }
+};
+const ShowError = (input: HTMLElement, formWrapper: HTMLElement, errorMessage?: string | UN, isNeedFocus?: boolean) => {
+  formWrapper.querySelector(".msg")?.remove();
+  const p = document.createElement("p") as HTMLParagraphElement;
+  p.classList.add("msg", "fw500", "fs-08");
+  p.style.color = "var(--B13)";
+  errorMessage = errorMessage ?? "Input is not valid";
+  p.innerHTML = errorMessage;
+  p.setAttribute("nlt", errorMessage ?? "");
+  formWrapper.querySelector(".smb")?.appendChild(p);
+  if (isNeedFocus) input.focus();
+};
+// ------------- End Input Error Handling -------------
+interface IValidationMessage {
+  message: string | UN;
+  isValid: boolean;
+}
+
+export const IsMatchRejex = (value?: string | UN, reg?: string | UN): boolean => {
+  if (!reg) return true;
+  const regex = new RegExp(reg);
+  return regex.test(value ?? "");
+};
+export function RequiredMessage(key?: string | UN) {
+  return IsNullOrEmpty(key) ? "Invalid Request, Required validation error." : `Invalid Request, ${MakeFirstLetterUpperCase(key ?? "")} is Required.`;
+}
+export function GetValidationMessage(inputParams: IInputRootParameters<any>): string {
+  const messages: string[] = [];
+  const param = inputParams as IInputParameters<any>;
+
+  if (param.isRequired) {
+    messages.push("This field is required.");
+  }
+
+  if (param.minLength && param.maxLength) messages.push(`Must be between ${param.minLength} and ${param.maxLength} characters.`);
+  else if (param.minLength) messages.push(`Minimum length is ${param.minLength} characters.`);
+  else if (param.maxLength) messages.push(`Maximum length is ${param.maxLength} characters.`);
+
+  if ((param as any).regexKey) {
+    const pattern = (param as any).regexKey;
+
+    if (pattern === "^[a-zA-Z0-9_]+$") messages.push("Only letters, numbers, and underscores are allowed.");
+    else if (pattern === "^[0-9]+$") messages.push("Only numbers are allowed.");
+    else if (pattern === "^[a-zA-Z]+$") messages.push("Only letters are allowed.");
+    else if (pattern === "^[a-zA-Z0-9]+$") messages.push("Only letters and numbers are allowed.");
+    else messages.push("Please follow the required format.");
+  }
+
+  return messages.join("<br>");
+}
+export function MinLengthNotValidMessage(key: string, min: number, isArrayOrList: boolean = false): string {
+  return !isArrayOrList ? `Invalid Request, ${MakeFirstLetterUpperCase(key)} must be at least ${min} characters long.` : `Invalid Request, Please provide at least ${min} ${MakeFirstLetterUpperCase(key)}.`;
+}
+export function MinDateNotValidMessage(key: string, min: Date): string {
+  //const formattedDate = EasyDateFormater(min, false);
+  const formattedDate = min;
+  return `Invalid Request, ${MakeFirstLetterUpperCase(key)} must be on or after ${formattedDate}.`;
+}
+
+export function MaxLengthNotValidMessage(key: string, max: number, isArrayOrList: boolean = false, isSelected?: boolean): string {
+  const formattedKey = MakeFirstLetterUpperCase(key);
+
+  if (isArrayOrList) return `You can provide a maximum of ${max} ${formattedKey}.`;
+  if (isSelected) return `You cannot select more than ${max} ${formattedKey}.`;
+  return `Invalid request: ${formattedKey} cannot exceed ${max} characters.`;
+}
+
+export function MaxDateNotValidMessage(key: string, max: Date): string {
+  //const formattedDate = EasyDateFormater(max, false);
+  const formattedDate = max;
+  return `Invalid Request, ${MakeFirstLetterUpperCase(key)} cannot be after ${formattedDate}.`;
+}
+export function InvalidValueMessage(key: string | UN): string {
+  return IsNullOrEmpty(key) ? "Invalid Request, Given value is not valid." : `Invalid Request, ${MakeFirstLetterUpperCase(key ?? "")} is not valid.`;
+}
+export function UnauthorizedMessage(key?: string) {
+  return IsNullOrEmpty(key) ? "Invalid Request, You haven't permission to access this." : `Invalid Request, You haven't permission to access ${MakeFirstLetterUpperCase(key)}.`;
+}

package/src/index.ts

@@ -1,5 +1,3 @@
-import "./load-env";
-
 // API services
 export * from "./api-services/preference-service";
 export * from "./api-services/system-service";
@@ -19,24 +17,10 @@ export * from "./helpers/string-helpers";
 export * from "./helpers/utility-helpers";
 
 // Interfaces
-export * from "./interfaces/browser-interfaces";
-export * from "./interfaces/button-interfaces";
-export * from "./interfaces/datasource-interfaces";
-export * from "./interfaces/datatable-interfaces";
-export * from "./interfaces/dialogbox-interfaces";
-export * from "./interfaces/http-interfaces";
-export * from "./interfaces/icon-interfaces";
-export * from "./interfaces/input-interfaces";
-export * from "./interfaces/layout-interfaces";
-export * from "./interfaces/menu-interfaces";
-export * from "./interfaces/permission-interfaces";
-export * from "./interfaces/storage-interfaces";
-export * from "./interfaces/system-interfaces";
-export * from "./interfaces/theme-interfaces";
-export * from "./interfaces/type-interfaces";
+export * from "./interface";
 
 // Core
 export * from "./nexus.environments";
+export * from "./proxy-api-server";
 export * from "./services/http-services";
 export * from "./sso-server";
- 

package/src/interface.ts

@@ -1,15 +1,19 @@
+export * from "./interfaces/auth-token-interfaces";
 export * from "./interfaces/browser-interfaces";
 export * from "./interfaces/button-interfaces";
-export * from "./interfaces/datatable-interfaces";
 export * from "./interfaces/datasource-interfaces";
+export * from "./interfaces/datatable-interfaces";
 export * from "./interfaces/dialogbox-interfaces";
+export * from "./interfaces/exception-interfaces";
 export * from "./interfaces/http-interfaces";
 export * from "./interfaces/icon-interfaces";
 export * from "./interfaces/input-interfaces";
 export * from "./interfaces/layout-interfaces";
 export * from "./interfaces/menu-interfaces";
+export * from "./interfaces/message-interfaces";
 export * from "./interfaces/permission-interfaces";
 export * from "./interfaces/storage-interfaces";
 export * from "./interfaces/system-interfaces";
 export * from "./interfaces/theme-interfaces";
 export * from "./interfaces/type-interfaces";
+export * from "./interfaces/user-interfaces";

package/src/interfaces/auth-token-interfaces.tsx

@@ -0,0 +1,6 @@
+/** Token lifetimes from TBAuthentications.ClientApplications (seconds). */
+export interface IClientTokenLifetimes {
+  accessTokenLifetimeSeconds: number;
+  refreshTokenLifetimeSeconds: number;
+  ssoSessionLifetimeSeconds: number;
+}

package/src/interfaces/browser-interfaces.tsx

@@ -1,3 +1,5 @@
+export const DEFAULT_MOBILE_VIEW_WIDTH = 768;
+
 export enum EKeys {
   TAB = "Tab",
   DELETE = "Delete",
@@ -21,3 +23,14 @@ export enum EKeyModifier {
   Ctrl = 1 << 1, // 2
   Alt = 1 << 2, // 4
 }
+export enum EFileSizes {
+  ORGINAL = 0,
+  SIZE_16 = 1,
+  SIZE_32 = 2,
+  SIZE_64 = 3,
+  SIZE_128 = 4,
+  SIZE_256 = 5,
+  SIZE_512 = 6,
+  SIZE_1024 = 7,
+  SIZE_2048 = 8,
+}

package/src/interfaces/button-interfaces.tsx

@@ -40,10 +40,10 @@ export interface IButton {
   iconSize?: ESizes | UN;
   columnSize?: number | UN;
   borderSize?: number | UN;
-  target?: ETargets | UN;
+  target?: ETargets | EButtonTypes | UN;
 }
 
-export const GetButton = (label?: string | StringCallbackHandler | string | UN, id?: string | UN, url?: string | UN, icon?: EIcons | UN, onClick?: ClickHandler | UN, data?: any | Event | UN, background?: EBackgrounds | UN, defaultClass?: string | UN, displayOrder?: number | UN, iconType?: EIconTypes | UN, iconSize?: ESizes | UN, columnSize?: number | UN, borderSize?: number | UN, target?: ETargets | UN): IButton => {
+export const GetButton = (label?: string | StringCallbackHandler | string | UN, id?: string | UN, url?: string | UN, icon?: EIcons | UN, onClick?: ClickHandler | UN, data?: any | Event | UN, background?: EBackgrounds | UN, defaultClass?: string | UN, displayOrder?: number | UN, iconType?: EIconTypes | UN, iconSize?: ESizes | UN, columnSize?: number | UN, borderSize?: number | UN, target?: ETargets | EButtonTypes | UN): IButton => {
   return {
     label: label,
     id: id,

package/src/interfaces/http-interfaces.tsx

@@ -1,6 +1,11 @@
+import { NEXUS_INFO } from "../nexus.environments";
+import { GetRootApi } from "../services/http-services";
 import { EErrorCodes, EExceptionCategories } from "./exception-interfaces";
+import { EModules } from "./system-interfaces";
 import { IInterface, UN } from "./type-interfaces";
 
+export const PROXY_PUBLIC_BASE_PATH = "/api/app";
+
 export enum EActions {
   Get = 1,
   Post = 2,
@@ -8,28 +13,32 @@ export enum EActions {
   Delete = 4,
 }
 export interface IApiInformations {
-  api: string;
+  module: EModules;
+  apiName: string;
   method: EActions;
 }
+
 export interface IGetApiInformations extends IApiInformations {
   cacheCode?: string;
   /** In Minutes */
   cacheLifetime?: number;
+  bodyType?: EBody;
+  parameters?: any;
 }
 
 export interface IRootRespose extends IInterface {
-  message: string | UN;
-  messageCode: string | UN;
   isSuccess: boolean;
   code: number;
-  exceptionCategory: EExceptionCategories | UN;
-  errorCode: EErrorCodes | UN;
-  inputName: string | UN;
-  result: any | UN;
+  message?: string | UN;
+  messageCode?: string | UN;
+  exceptionCategory?: EExceptionCategories | UN;
+  errorCode?: EErrorCodes | UN;
+  inputName?: string | UN;
+  result?: any | UN;
 }
 
 export interface IErrorRespose extends IRootRespose {
-  exception: any | UN;
+  exception?: any | UN;
 }
 export interface ISuccessResponse extends IRootRespose {}
 export enum EBody {
@@ -49,3 +58,72 @@ export const GetMethod = (method?: EActions) => {
       return "GET";
   }
 };
+
+export const GetResponse = {
+  ERROR: (message: string = "An error occurred.", messageCode: string = "GENERIC_ERROR", exceptionCategory: EExceptionCategories = EExceptionCategories.Application, errorCode: EErrorCodes = EErrorCodes.Unknown, inputName: string | undefined = undefined, exception: any | null = null, code: number = 400): IErrorRespose => ({
+    isSuccess: false,
+    exception: exception,
+    code: code,
+    message: message,
+    messageCode: messageCode,
+    exceptionCategory: exceptionCategory,
+    errorCode: errorCode,
+    inputName: inputName,
+    result: null,
+  }),
+  SUCCESS: (result: any | UN, message: string = "Success", messageCode: string = "SUCCESS", code: number = 200): ISuccessResponse => ({
+    isSuccess: true,
+    result: result,
+    message: message,
+    messageCode: messageCode,
+    code: code,
+  }),
+};
+
+const GET_API_KEYS = ["cacheCode", "cacheLifetime", "bodyType", "parameters"];
+const _isApi = (apiInformations: any | IApiInformations): boolean => {
+  if (!apiInformations || (!apiInformations.module && apiInformations.module !== EModules.None) || !apiInformations.apiName || !apiInformations.method) return false;
+  return true;
+};
+
+export const GetApiInformations = {
+  API: (module: EModules, apiName: string, method?: EActions | UN): IApiInformations => ({
+    module: module,
+    apiName: apiName,
+    method: method ?? EActions.Get,
+  }),
+  IS_API: _isApi,
+  GET_API: (module: EModules, apiName: string, method?: EActions | UN, cacheCode?: string | UN, cacheLifetime?: number | UN, bodyType?: EBody | UN, parameters?: any | UN): IGetApiInformations => {
+    return {
+      module: module,
+      apiName: apiName,
+      method: method ?? EActions.Get,
+      cacheCode: cacheCode,
+      cacheLifetime: cacheLifetime,
+      bodyType: bodyType,
+      parameters: parameters,
+    } as IGetApiInformations;
+  },
+  IS_GET_API: (apiInformations: any | IApiInformations): boolean => {
+    if (!_isApi(apiInformations)) return false;
+    const keys = Object.keys(apiInformations);
+    return GET_API_KEYS.every((key) => keys.includes(key));
+  },
+  BUILD_API: (apiInformations: IApiInformations, parameters?: any | UN) => {
+    const isProxyServer = NEXUS_INFO.IS_PROXY_SERVER;
+    if (isProxyServer) return BuildProxyApiUrl(apiInformations.module, apiInformations.apiName);
+    return `${GetRootApi(apiInformations.module)}/${apiInformations.apiName}`;
+  },
+};
+export const BuildProxyApiUrl = (module: EModules, relativePath: string, query?: string): string => {
+  const normalizedPath = relativePath.replace(/^\/+/, "");
+  if (module === EModules.None) return `/api/${normalizedPath}`;
+  const base = `${PROXY_PUBLIC_BASE_PATH}/${module}/${normalizedPath}`;
+
+  if (!query) {
+    return base;
+  }
+
+  const normalizedQuery = query.replace(/^\?+/, "");
+  return normalizedQuery ? `${base}?${normalizedQuery}` : base;
+};

package/src/interfaces/icon-interfaces.tsx

@@ -1,5 +1,8 @@
+import { ESizes } from "./layout-interfaces";
+
 export const DEFAULT_ICON_ELEMENT_NAME = "ion-icon";
 export const DEFAULT_SMALL_ICON_BOX_SIZE = 1 / 1.25;
+export const DEFAULT_ICON_SIZE = ESizes.VerySmall;
 export enum EIconTypes {
   OUTLINED = "-outline",
   SHARP = "-sharp",