nexus-shared 1.1.5 → 1.1.7

package/src/components/layouts/global-layout.tsx

@@ -0,0 +1,63 @@
+import Script from "next/script";
+import React from "react";
+import {
+  IGlobalLayout,
+  ROOT_LOADER_IDENTITY,
+} from "../../interfaces/layout-interfaces";
+import { FILES } from "../../nexus.environments";
+import { LayoutHelpers } from "./layout-helpers";
+
+import "./../../styles/nexus.animation.css";
+import "./../../styles/nexus.core.css";
+import "./../../styles/nexus.dialog.css";
+import "./../../styles/nexus.icon.css";
+import "./../../styles/nexus.input.css";
+import "./../../styles/nexus.loader.css";
+import "./../../styles/nexus.logic.css";
+import "./../../styles/nexus.utility.css";
+
+export const GlobalLayout = async ({
+  children,
+  globalLayout,
+}: Readonly<{ children: React.ReactNode; globalLayout: IGlobalLayout }>) => {
+  return (
+    <React.Fragment>
+      <LayoutHelpers globalLayout={globalLayout} />
+      <div
+        style={{
+          zIndex: "1000",
+          width: "100vw",
+          height: "100vh",
+          position: "fixed",
+          display: "flex",
+          justifyContent: "center",
+          alignItems: "center",
+          backgroundColor: "rgb(40, 40, 40)",
+        }}
+        id={ROOT_LOADER_IDENTITY}
+      >
+        <img
+          src={FILES.LOGO.ICON}
+          alt={"logo"}
+          style={{
+            minHeight: "3rem",
+            minWidth: "3rem",
+            width: "3rem",
+            height: "3rem",
+          }}
+        />
+      </div>
+      {children}
+      <Script
+        type="module"
+        src="https://cdn.jsdelivr.net/npm/ionicons@5.5.2/dist/ionicons/ionicons.esm.js"
+        strategy="lazyOnload"
+      ></Script>
+      <Script
+        noModule
+        src="https://cdn.jsdelivr.net/npm/ionicons@5.5.2/dist/ionicons/ionicons.js"
+        strategy="lazyOnload"
+      ></Script>
+    </React.Fragment>
+  );
+};

package/src/components/layouts/layout-helpers.tsx

@@ -0,0 +1,21 @@
+import { useEffect } from "react";
+import { RemoveElement } from "../../helpers/browser-helpers";
+import { IGlobalLayout, ROOT_LOADER_IDENTITY } from "../../interfaces/layout-interfaces";
+import { DEFAULT_THEME_INFORMATIONS } from "../../interfaces/theme-interfaces";
+import { O } from "../../nexus-client";
+import { InitializeStyles } from "../../services/theme-service";
+
+export const LayoutHelpers = ({ globalLayout }: Readonly<{ globalLayout: IGlobalLayout }>) => {
+  useEffect(() => {
+    globalLayout.systemThemes = DEFAULT_THEME_INFORMATIONS;
+    O.systemThemes = DEFAULT_THEME_INFORMATIONS;
+
+    const timeout = setTimeout(() => {
+      clearTimeout(timeout);
+      RemoveElement(ROOT_LOADER_IDENTITY, 500);
+      InitializeStyles();
+    }, 50);
+  }, []);
+
+  return <div className="nexus-popup-container"></div>;
+};

package/src/components/layouts/utility-menu.tsx

@@ -0,0 +1,69 @@
+import React, { JSX } from "react";
+import { EIconTypes } from "../../interfaces/icon-interfaces";
+import { EPositions, ESizes, IGlobalLayout } from "../../interfaces/layout-interfaces";
+import { GetUtilityMenuCode, IPanelMenu, IUtilityMenu, UTILITIES_BUTTON_PREFIX } from "../../interfaces/menu-interfaces";
+import { EBackgrounds } from "../../interfaces/theme-interfaces";
+import { Iconbox } from "../documents/icon-box";
+import { PageTitle } from "../documents/page-title";
+import { ThemePanel } from "../panels/theme-panel";
+import { GlobalDialogbox } from "./global-dialogbox";
+
+export const BUTTON_IDENTITY = (isneedPrefix: boolean) => {
+  const _ = isneedPrefix ? UTILITIES_BUTTON_PREFIX : "";
+  return {
+    PROFILE_BOX: `${_}profile`,
+    SEARCH_BOX: `${_}root-search`,
+    FAVORITE_BOX: `${_}favorite-menu`,
+    CARD_BOX: `${_}cart-menu`,
+    THEME_BOX: `${_}switch-theme`,
+    MEGA_BOX: `${_}mega-menu`,
+    SIGN_IN_BUTTON: `${_}sign-in`,
+    SIGN_OUT_BUTTON: `${_}sign-out`,
+  };
+};
+export const UtilityMenu = ({ utilityMenus, userPanels, column, paddingRight, globalLayout, iconBoxBackground }: Readonly<{ utilityMenus: IUtilityMenu[]; userPanels: IPanelMenu[]; column?: number; paddingRight?: number; globalLayout: IGlobalLayout; iconBoxBackground: EBackgrounds }>) => {
+  return (
+    <div style={{ paddingRight: paddingRight ?? 0, zIndex: 3 }} className={`utilities df fr ac jr h100p col-${column ?? 12}`}>
+      {utilityMenus.map((utilityMenu, index) => (
+        <UtilityIcon key={index} utilityMenu={utilityMenu} boxBackground={iconBoxBackground} globalLayout={globalLayout} />
+      ))}
+      <ProfilePanel globalLayout={globalLayout} boxBackground={iconBoxBackground} userPanels={userPanels} />
+    </div>
+  );
+};
+
+const UtilityIcon = ({ utilityMenu, globalLayout, boxBackground }: Readonly<{ utilityMenu: IUtilityMenu; globalLayout: IGlobalLayout; boxBackground?: EBackgrounds }>) => {
+  return (
+    <Iconbox id={GetUtilityMenuCode(utilityMenu.menuCode)} icon={utilityMenu.menuIcon} iconType={EIconTypes.FILLED} iconSize={ESizes.Small} boxSize={ESizes.Small} background={boxBackground} defaultClass="mr2">
+      <UtilityDialogBox utilityMenu={utilityMenu} globalLayout={globalLayout} />
+    </Iconbox>
+  );
+};
+
+export const ProfilePanel = ({ globalLayout, userPanels, boxBackground }: Readonly<{ globalLayout: IGlobalLayout; userPanels: IPanelMenu[]; boxBackground?: EBackgrounds }>): JSX.Element => {
+  return (
+    <div className={`pr ${ESizes.Small} ib ${boxBackground} h p2 r`}>
+      <h6>BA</h6>
+    </div>
+  );
+};
+
+const UtilityDialogBox = ({ utilityMenu, globalLayout }: Readonly<{ utilityMenu: IUtilityMenu; globalLayout: IGlobalLayout }>) => {
+  return (
+    <GlobalDialogbox hoverEffectDelay={true} defaultPadding={5} position={EPositions.Left} buttonIdentity={GetUtilityMenuCode(utilityMenu.menuCode)} defaultWidth={30}>
+      <div>
+        <PageTitle marginBottom={5} borderBottom={1} title={utilityMenu.menuName} />
+        <UtilityPanel utilityMenu={utilityMenu} globalLayout={globalLayout} />
+      </div>
+    </GlobalDialogbox>
+  );
+};
+
+const UtilityPanel = ({ utilityMenu, globalLayout }: Readonly<{ utilityMenu: IUtilityMenu; globalLayout: IGlobalLayout }>) => {
+  switch (utilityMenu.menuCode) {
+    case BUTTON_IDENTITY(false).THEME_BOX:
+      return <ThemePanel />;
+    default:
+      return <div>Unknown Panel: {utilityMenu.menuName}</div>;
+  }
+};

package/src/components/panels/theme-panel.tsx

@@ -0,0 +1,44 @@
+import React, { useEffect } from "react";
+import { GetButton, IButton } from "../../interfaces/button-interfaces";
+import { EIconTypes } from "../../interfaces/icon-interfaces";
+import { ClickHandler } from "../../interfaces/type-interfaces";
+import { O } from "../../nexus-client";
+import { GetCurrentThemeName, SetCurrentTheme } from "../../services/localstorage-service";
+import { SwitchTheme } from "../../services/theme-service";
+import { CreateTabButtons } from "../documents/tab-button";
+
+const onClicked: ClickHandler = (event, element, button: IButton) => {
+  if (button.id === GetCurrentThemeName()) return;
+  const themeCode = button.id;
+  if (!themeCode) return;
+  SwitchTheme(themeCode);
+  SetCurrentTheme(themeCode);
+};
+const RenderSwitchTheme = (baseElement: HTMLElement) => {
+  if (!baseElement || baseElement.classList.contains("ddcc")) return;
+  baseElement.classList.add("ddcc");
+
+  const currentTheme = GetCurrentThemeName();
+  const themes = O.systemThemes;
+
+  if (!themes || themes.length === 0) {
+    const p = document.createElement("p");
+    p.textContent = "No theme available!";
+    p.className = "o08 p5 bg3 tc";
+    baseElement.appendChild(p);
+    return;
+  }
+  const themeButtons: IButton[] = themes.map((theme, index) => GetButton(theme.displayName, theme.systemName, null, theme.icon, onClicked, theme, null, null, theme.displayOrder, EIconTypes.FILLED, null));
+  const activeButton = themeButtons.find((button) => button.id === currentTheme);
+  CreateTabButtons(themeButtons, baseElement, activeButton, onClicked);
+
+  return "Theme Settings";
+};
+
+export const ThemePanel = () => {
+  const containerRef = React.useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    if (containerRef.current) RenderSwitchTheme(containerRef.current);
+  }, [containerRef.current]);
+  return <div ref={containerRef}></div>;
+};

package/src/helpers/bitwise-helpers.tsx

@@ -0,0 +1,11 @@
+export function HasFlag(state: number, flag: number): boolean {
+  return (state & flag) === flag;
+}
+export function BitwiseToList<T>(enumType: any, bitwiseValue: number): T[] {
+  return Object.values(enumType)
+    .filter((v) => typeof v === "number")
+    .filter((v: number) => (bitwiseValue & v) === v && v !== 0) as T[];
+}
+export function ListToBitwise(values: number[]): number {
+  return values.reduce((acc, curr) => acc | curr, 0);
+}

package/src/helpers/browser-helpers.tsx

@@ -0,0 +1,71 @@
+import { EAnimationClasses } from "../interfaces/layout-interfaces";
+import { NEXUS_INFO } from "../nexus.environments";
+import { EKeyModifier, EKeys } from "./../interfaces/browser-interfaces";
+import { HasFlag } from "./bitwise-helpers";
+import { Debounce } from "./utility-helpers";
+
+export const IsBrowser = (): boolean => typeof window !== "undefined" && typeof document !== "undefined";
+
+export const RemoveElement = async (elementIdentity: string | HTMLElement, timeout?: number, animation?: EAnimationClasses): Promise<boolean> => {
+  return new Promise(async (resolve) => {
+    if (!IsBrowser() || !elementIdentity) return resolve(false);
+    else if (typeof elementIdentity === "string") {
+      const element = document.getElementById(elementIdentity);
+      if (element) return await RemoveElement(element, timeout);
+    } else if (elementIdentity instanceof HTMLElement || (elementIdentity as HTMLElement)) {
+      const timeoutIdentifier = setTimeout(() => {
+        (elementIdentity as HTMLElement).remove();
+        clearTimeout(timeoutIdentifier);
+        elementIdentity.remove();
+        return resolve(true);
+      }, timeout ?? 0);
+      elementIdentity.classList.add(animation ?? EAnimationClasses.FADE_OUT);
+      return resolve(true);
+    } else return resolve(false);
+  });
+};
+
+const setDocumentTitle = (title?: string) => IsBrowser() && (document.title = `Nexus - ${title ?? NEXUS_INFO.CURRENT_MODULE_SHORT_NAME ?? "Solutions"}`);
+export const SetDocumentTitleDebounce = Debounce(setDocumentTitle, 100);
+
+export const ConvertRemToPixels = (rem: number): number => {
+  const fontSize = parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+  return Math.round(rem * fontSize * 1000) / 1000;
+};
+
+export const ConvertPixelsToRem = (px: number): number => {
+  const fontSize = parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+  return Math.round((px / fontSize) * 1000) / 1000;
+};
+export const IsKeyPressed = (event: any, key: EKeys | string, modifier?: EKeyModifier): boolean => {
+  const isPressed = (event?.key ?? event?.nativeEvent?.data) === key;
+  if (!isPressed) return isPressed;
+
+  if (!modifier) return isPressed;
+
+  if (HasFlag(modifier, EKeyModifier.Shift) && !event.shiftKey) return false;
+  if (HasFlag(modifier, EKeyModifier.Ctrl) && !event.ctrlKey) return false;
+  if (HasFlag(modifier, EKeyModifier.Alt) && !event.altKey) return false;
+
+  return isPressed;
+};
+export const IsValidURL = (url?: string | null) => url !== undefined && url !== null && url !== "#" && url.length > 0;
+
+export const FindChildElement = (parent: HTMLElement, childSelector: string, shouldScanAllChildren: boolean = false) => {
+  if (!parent || !childSelector) return null;
+  if (shouldScanAllChildren) {
+    const children = parent.querySelectorAll(childSelector);
+    return children.length > 0 ? children[0] : null;
+  } else return parent.querySelector(childSelector);
+};
+
+export const FindChildElements = (parent: HTMLElement, childSelector: string, shouldScanAllChildren: boolean = false) => {
+  if (!parent || !childSelector) return [];
+  if (shouldScanAllChildren) {
+    const children = parent.querySelectorAll(childSelector);
+    return children.length > 0 ? children : [];
+  } else {
+    const children = parent.querySelectorAll(childSelector);
+    return children.length > 0 ? [children[0]] : [];
+  }
+};

package/src/helpers/datasource-helpers.tsx

@@ -0,0 +1,99 @@
+import { IColumn } from "../interfaces/datatable-interfaces";
+import { IsNullOrEmpty } from "./string-helpers";
+
+export function GetVisibleAndHiddenItems<T>(allItems: T[], visibleRef: T[], hiddenRef: T[], activeItem: T | undefined, maxVisibleCount: number): { visibleItems: T[]; hiddenItems: T[] } {
+  let visibleItems: T[] = [];
+  let hiddenItems: T[] = [];
+  visibleRef.length = 0;
+  hiddenRef.length = 0;
+
+  if (allItems.length <= maxVisibleCount) {
+    const _ = {
+      visibleItems: allItems,
+      hiddenItems: [],
+    };
+    visibleRef.push(..._.visibleItems);
+    hiddenRef.push(..._.hiddenItems);
+    return _;
+  }
+
+  if (!activeItem || !allItems.includes(activeItem)) {
+    visibleItems = allItems.slice(0, maxVisibleCount);
+    hiddenItems = allItems.slice(maxVisibleCount);
+  } else {
+    const index = allItems.indexOf(activeItem);
+    // It means the active item is within the visible range
+    const selectedItem = allItems[index];
+    // 0 to maxVisibleCount - 1
+    visibleItems = allItems.slice(0, maxVisibleCount - 1);
+    visibleItems.push(selectedItem);
+    hiddenItems = allItems.slice(maxVisibleCount - 1);
+    // remove the hidden but active item from the hidden items
+    hiddenItems = hiddenItems.filter((item) => item !== selectedItem);
+    if (index > maxVisibleCount - 1) {
+    } else {
+      visibleItems = allItems.slice(0, maxVisibleCount);
+      hiddenItems = allItems.slice(maxVisibleCount);
+    }
+  }
+  visibleRef.push(...visibleItems);
+  hiddenRef.push(...hiddenItems);
+  return { visibleItems, hiddenItems };
+}
+export function DynamicSorting<T>(data: T[], key: keyof T, isAsc: boolean) {
+  return [...data].sort((a, b) => {
+    const aValue = a[key];
+    const bValue = b[key];
+    let result = 0;
+
+    // **Handle null & undefined values**
+    if (aValue == null && bValue == null) return 0;
+    if (aValue == null) return isAsc ? -1 : 1;
+    if (bValue == null) return isAsc ? 1 : -1;
+
+    // **Handle numbers**
+    if (typeof aValue === "number" && typeof bValue === "number") result = aValue - bValue;
+    // **Handle strings**
+    else if (typeof aValue === "string" && typeof bValue === "string") result = aValue.localeCompare(bValue);
+    // **Handle dates**
+    else if (aValue instanceof Date && bValue instanceof Date) result = aValue.getTime() - bValue.getTime();
+    // **Handle objects (fallback)**
+    else if (typeof aValue === "object" && typeof bValue === "object") result = JSON.stringify(aValue).localeCompare(JSON.stringify(bValue));
+    // **Handle mixed types (fallback)**
+    else result = String(aValue).localeCompare(String(bValue));
+
+    return isAsc ? result : -result;
+  });
+}
+export function CreateClone<T>(data: T | T[], index?: number, object?: T): T | T[] {
+  // Check if the input is an array
+  if (Array.isArray(data)) {
+    // Clone each element in the array
+    let clonedArray = data.map((item) => ({ ...item }));
+
+    // If both index and object are provided, add the object at the specified index
+    if (index !== undefined && object !== undefined) {
+      // Insert object at the specified index
+      clonedArray.splice(index, 0, { ...object });
+    }
+    return clonedArray;
+  } else if (typeof data === "object" && data !== null)
+    // Clone a single object
+    return { ...data };
+  else throw new Error("Input must be an object or an array of objects");
+}
+export const SearchDatasourceUsingColumns = (dataSource: any[], searchText: string | null, columns: IColumn[]) => {
+  if (!dataSource || !Array.isArray(dataSource) || dataSource.length === 0 || !columns || columns.length === 0 || IsNullOrEmpty(searchText)) return dataSource;
+  const searchableColumns = columns.filter((column) => column.isSearchable);
+  if (searchableColumns.length === 0) return dataSource;
+  const searchLower = searchText?.toLowerCase().trim();
+  return dataSource.filter((data) => {
+    return searchableColumns.some((column) => {
+      if (column.systemName) {
+        const value = data[column.systemName];
+        return value && value.toString().toLowerCase().includes(searchLower);
+      }
+      return false;
+    });
+  });
+};

package/src/helpers/element-helpers.tsx

@@ -0,0 +1,57 @@
+import { UN } from "../interfaces/type-interfaces";
+
+export function RenderChildren<T>(parentContainer: HTMLElement, elementList: HTMLElement[], toggleButton: HTMLElement, activeItem: T | UN, visibleItems: T[], hiddenItems: T[], createItem: (item: T) => HTMLElement, refreshElementClass: (element: HTMLElement, activeItem: T | UN) => void, isInit: boolean, isHiddenItemClicked: boolean, dataUniqueKey: string, dataAttributeKey: string) {
+  if (!isInit) {
+    // Update classes for all item links based on activeItem
+    for (const element of elementList) refreshElementClass(element, activeItem);
+    if (isHiddenItemClicked && activeItem) {
+      // A hidden item was clicked: replace last visible item in DOM with the active one
+      const newActiveItem = createItem(activeItem);
+      const lastItemElement = elementList[elementList.length - 1];
+
+      if (lastItemElement) {
+        lastItemElement.replaceWith(newActiveItem);
+        elementList[elementList.length - 1].remove();
+        elementList[elementList.length - 1] = newActiveItem;
+      }
+    } else {
+      // Ensure last visible DOM element matches last item in visibleItems
+      const lastVisible = visibleItems[visibleItems.length - 1];
+      const lastDomItem = elementList[elementList.length - 1];
+
+      const currentItemCode = lastDomItem?.getAttribute(dataAttributeKey);
+      if (lastVisible && lastDomItem && currentItemCode !== (lastVisible as any)[dataUniqueKey]) {
+        const correctedItem = createItem(lastVisible);
+        lastDomItem.replaceWith(correctedItem);
+        lastDomItem.remove();
+        elementList[elementList.length - 1] = correctedItem;
+      }
+    }
+    return;
+  }
+
+  // Initial render: clear and create full visible item
+  elementList.length = 0;
+  parentContainer.innerHTML = "";
+
+  for (const item of visibleItems) {
+    const itemItem = createItem(item);
+    parentContainer.appendChild(itemItem);
+    elementList.push(itemItem);
+  }
+
+  // Append toggle icon if hidden items exist
+  if (hiddenItems.length > 0) {
+    parentContainer.appendChild(toggleButton);
+  }
+}
+export const SetElementStyles = (element: HTMLElement, styles: React.CSSProperties | UN) => {
+  if (!element || !styles) return;
+  if (typeof styles === "object") {
+    Object.keys(styles).forEach((key) => {
+      const value = styles[key as keyof typeof styles];
+      if (value === undefined) return;
+      element.style.setProperty(key, value === null ? null : String(value));
+    });
+  } else element.style.setProperty(styles as string, styles as string);
+};

package/src/helpers/input-helpers.tsx

@@ -0,0 +1,24 @@
+import { EValueChangeTypes, IInputCreateResults, IInputRootParameters } from "../interfaces/input-interfaces";
+import { ESizes } from "../interfaces/layout-interfaces";
+import { UN } from "../interfaces/type-interfaces";
+
+export const GetParentKey = (parentKey?: string | null) => {
+  if (parentKey) return parentKey.split("|")[0];
+  return undefined;
+};
+export const GetInputId = (param: IInputRootParameters<any>) => param.id.split("-")[0];
+export const GetInputClasses = (size?: ESizes | UN, cls?: string | UN) => `ipt pr sn ${size ?? ""} ${cls ?? ""}`;
+export const SetHaveValueClass = (input: HTMLElement, isHaveValue: boolean) => {
+  if (!input) return;
+  input.classList.toggle("txhv", isHaveValue);
+};
+export const ForceSetValues = (inputs: IInputCreateResults[] | UN, keys: string[] | UN, value: any | null, timeout?: number | UN, invokeOnChanged?: boolean | UN) => {
+  if (!inputs || inputs.length === 0) return;
+  for (const input of inputs) if (!keys || keys.length === 0 || keys.includes(GetInputId(input.input))) ForceSetValue(input, value, timeout, invokeOnChanged);
+};
+export const ForceSetValue = (input?: IInputCreateResults | null, value?: any | null, timeout?: number | UN, invokeOnChanged?: boolean | UN) => {
+  const timeoutValue = setTimeout(() => {
+    input?.forceChangeDefaultValue && input.forceChangeDefaultValue(value, EValueChangeTypes.ForceChanged, invokeOnChanged);
+    clearTimeout(timeoutValue);
+  }, timeout ?? 0);
+};

package/src/helpers/string-helpers.tsx

@@ -0,0 +1,28 @@
+import { UN } from "../interfaces/type-interfaces";
+
+export const ConvertToCode = (text: string | UN) => text?.toString().toLowerCase().replace(/\s+/g, "-") ?? null;
+
+export const IsNullOrEmpty = (value?: string | null) => !(value !== null && value !== undefined && value.toString().trim().length > 0);
+export function MakeFirstLetterUpperCase(str?: string) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+export const GetRandomNumber = (min = 0, max = 100) => Math.floor(Math.random() * (max - min + 1)) + min;
+export const GetRandomString = (length: number = 10, includeNumbers: boolean = true, includeSpecialChars: boolean = false): string => {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + (includeNumbers ? "0123456789" : "") + (includeSpecialChars ? "!@#$%^&*()_+-=[]{}|;:,.<>?/" : "");
+  let result = "";
+
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters[randomIndex];
+  }
+
+  return result;
+};
+export function PadStart(value: string | number | null | undefined, targetLength: number, padString: string = "0"): string {
+  if (value == null || value === undefined) return "";
+
+  const str = value?.toString();
+  if (str.length >= targetLength) return str;
+  return padString.repeat(targetLength - str.length) + str;
+}

package/src/helpers/utility-helpers.tsx

@@ -0,0 +1,44 @@
+const DEFAULT_DELAY = 500;
+
+export type DebouncedFunction<T extends (...args: any[]) => void> = ((...args: Parameters<T>) => void) & {
+  cancel: () => void;
+  executeImmediately: (...args: Parameters<T>) => void;
+};
+
+export function Debounce<T extends (...args: any[]) => void>(func: T, delay?: number): DebouncedFunction<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let lastArgs: Parameters<T> | undefined;
+  let isPending = false;
+
+  const debounced = (...args: Parameters<T>) => {
+    lastArgs = args;
+    isPending = true;
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = undefined;
+      isPending = false;
+      lastArgs = undefined;
+      func(...args);
+    }, delay ?? DEFAULT_DELAY);
+  };
+
+  /** Cancel the debounced function */
+  debounced.cancel = () => {
+    clearTimeout(timer);
+    timer = undefined;
+    isPending = false;
+    lastArgs = undefined;
+  };
+
+  /** Execute the debounced function immediately */
+  debounced.executeImmediately = (...args: Parameters<T>) => {
+    clearTimeout(timer);
+    timer = undefined;
+    const invokeArgs = args.length > 0 ? args : isPending ? lastArgs : undefined;
+    isPending = false;
+    lastArgs = undefined;
+    if (invokeArgs !== undefined) func(...invokeArgs);
+  };
+
+  return debounced;
+}

package/src/index.ts

@@ -1,11 +1,67 @@
-/**
- * Unified entry — re-exports interface, server, and client modules.
- *
- * Prefer subpath imports in client-only code:
- * - `@nexus/core/interface`
- * - `@nexus/core/server`
- * - `@nexus/core/client`
- */
-export * from "./interface";
-export * from "./server";
-export * from "./client";
+import "./load-env";
+
+// API services
+export * from "./api-services/preference-service";
+export * from "./api-services/system-service";
+
+// Components — documents
+export * from "./components/documents/button";
+export * from "./components/documents/icon-box";
+export * from "./components/documents/page-title";
+export * from "./components/documents/tab-button";
+
+// Components — inputs
+export * from "./components/inputs/checkbox-input";
+export * from "./components/inputs/input";
+export * from "./components/inputs/input-box";
+export * from "./components/inputs/input-element";
+export * from "./components/inputs/input-form";
+export * from "./components/inputs/number-input";
+export * from "./components/inputs/radiobox-input";
+export * from "./components/inputs/textarea-input";
+export * from "./components/inputs/textbox-input";
+
+
+// Components — layouts
+export * from "./components/layouts/global-layout";
+export * from "./components/layouts/global-dialogbox";
+export * from "./components/layouts/layout-helpers";
+export * from "./components/layouts/utility-menu";
+
+// Components — panels
+export * from "./components/panels/theme-panel";
+
+// Helpers
+export * from "./helpers/bitwise-helpers";
+export * from "./helpers/browser-helpers";
+export * from "./helpers/datasource-helpers";
+export * from "./helpers/element-helpers";
+export * from "./helpers/input-helpers";
+export * from "./helpers/string-helpers";
+export * from "./helpers/utility-helpers";
+
+// Interfaces
+export * from "./interfaces/browser-interfaces";
+export * from "./interfaces/button-interfaces";
+export * from "./interfaces/datatable-interfaces";
+export * from "./interfaces/datasource-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";
+
+// Services
+export * from "./services/loader-service";
+export * from "./services/localstorage-service";
+export * from "./services/theme-service";
+
+// Core
+export * from "./nexus-client";
+export * from "./nexus.environments";

package/src/interfaces/browser-interfaces.tsx

@@ -0,0 +1,23 @@
+export enum EKeys {
+  TAB = "Tab",
+  DELETE = "Delete",
+  ENTER = "Enter",
+  ESCAPE = "Escape",
+  SPACE = " ",
+  BACKSPACE = "Backspace",
+  ARROW_UP = "ArrowUp",
+  ARROW_DOWN = "ArrowDown",
+  ARROW_LEFT = "ArrowLeft",
+  ARROW_RIGHT = "ArrowRight",
+  A = "a",
+  B = "b",
+  C = "c",
+  D = "d",
+  DOT = ".",
+}
+export enum EKeyModifier {
+  None = 0,
+  Shift = 1 << 0, // 1
+  Ctrl = 1 << 1, // 2
+  Alt = 1 << 2, // 4
+}