@nexus-cross/design-system 1.0.0

package/dist/chunks/chunk-HNLI646G.mjs

@@ -0,0 +1,325 @@
+import { Skeleton } from './chunk-P2T72N62.mjs';
+import { cn } from './chunk-MCKOWMLS.mjs';
+import { orderBy } from 'lodash-es';
+import React, { createContext, useContext, useState, useCallback, useMemo, Children, isValidElement, Fragment } from 'react';
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
+import { cva } from 'class-variance-authority';
+
+var TableHighlightContext = createContext({
+  highlightValue: null,
+  setHighlightValue: () => {
+  }
+});
+var useTableHighlight = () => useContext(TableHighlightContext);
+var TableHighlightProvider = ({ children }) => {
+  const [highlightValue, setHighlightValue] = useState(null);
+  return /* @__PURE__ */ jsx(TableHighlightContext.Provider, { value: { highlightValue, setHighlightValue }, children });
+};
+var ALIGN_CLASSES = {
+  center: "nexus-td--center",
+  left: "nexus-td--left",
+  right: "nexus-td--right"
+};
+var TEXT_OVERFLOW_CLASSES = {
+  auto: "nexus-td--nowrap",
+  truncate: "nexus-td--truncate",
+  wrap: "nexus-td--wrap",
+  "break-all": "nexus-td--break-all"
+};
+var TdColumn = ({
+  className = "",
+  children,
+  fieldId,
+  size,
+  colSpan,
+  rowSpan,
+  align = "left",
+  textOverflow = "truncate",
+  highlightKey
+}) => {
+  const { highlightValue, setHighlightValue } = useTableHighlight();
+  const isHighlighted = !!highlightKey && !!highlightValue && highlightKey === highlightValue;
+  const handleMouseEnter = useCallback(() => {
+    if (highlightKey) setHighlightValue(highlightKey);
+  }, [highlightKey, setHighlightValue]);
+  const handleMouseLeave = useCallback(() => {
+    if (highlightKey) setHighlightValue(null);
+  }, [highlightKey, setHighlightValue]);
+  const sizeStyle = size ? { width: typeof size === "number" ? `${size}px` : size, flex: `0 0 ${typeof size === "number" ? `${size}px` : size}` } : void 0;
+  return /* @__PURE__ */ jsx(
+    "td",
+    {
+      className: cn("nexus-td", fieldId, className),
+      title: textOverflow === "truncate" && typeof children === "string" ? children : void 0,
+      colSpan,
+      rowSpan,
+      style: sizeStyle,
+      onMouseEnter: handleMouseEnter,
+      onMouseLeave: handleMouseLeave,
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: cn(
+            typeof children !== "string" && "nexus-td__inner--flex",
+            TEXT_OVERFLOW_CLASSES[textOverflow],
+            ALIGN_CLASSES[align],
+            "nexus-td__inner",
+            isHighlighted && "nexus-td__inner--highlight"
+          ),
+          children
+        }
+      )
+    }
+  );
+};
+TdColumn.displayName = "TdColumn";
+var tableRowVariants = cva("nexus-table-row", {
+  variants: {
+    variant: {
+      default: "nexus-table-row--default",
+      accent: "nexus-table-row--accent"
+    }
+  },
+  defaultVariants: { variant: "default" }
+});
+var TableRow = ({ className = "", children, onClick, variant = "default" }) => {
+  const columnList = useMemo(() => {
+    const getChildren = (childArray) => {
+      return childArray.flatMap((child) => {
+        if (!React.isValidElement(child)) return [];
+        const childType = child.type;
+        if (childType?.displayName === "TdColumn") {
+          return child;
+        }
+        const childProps = child.props;
+        if (Array.isArray(childProps?.children)) {
+          return getChildren(childProps.children);
+        }
+        return [];
+      });
+    };
+    const childList = Array.isArray(children) ? children : [children];
+    return getChildren(childList);
+  }, [children]);
+  return /* @__PURE__ */ jsx("tr", { className: cn(tableRowVariants({ variant }), className), onClick, children: columnList });
+};
+TableRow.displayName = "TableRow";
+var DefaultSortIcon = ({ direction }) => /* @__PURE__ */ jsxs("svg", { className: "nexus-table-sort-icon", viewBox: "0 0 16 16", fill: "currentColor", children: [
+  direction === "asc" && /* @__PURE__ */ jsx("path", { d: "M8 4l4 5H4z" }),
+  direction === "desc" && /* @__PURE__ */ jsx("path", { d: "M8 12l4-5H4z" }),
+  direction === "default" && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    /* @__PURE__ */ jsx("path", { d: "M8 4l3 3.5H5z", opacity: 0.3 }),
+    /* @__PURE__ */ jsx("path", { d: "M8 12l3-3.5H5z", opacity: 0.3 })
+  ] })
+] });
+var findTdColumns = (children) => {
+  let result = [];
+  Children.forEach(children, (child) => {
+    if (isValidElement(child)) {
+      if (child.type === Fragment) {
+        result = [...result, ...findTdColumns(child.props.children)];
+      } else if (child.type === TdColumn || child.type?.displayName === "TdColumn") {
+        result.push(child);
+      } else {
+        result = [...result, ...findTdColumns(child?.props?.children)];
+      }
+    }
+  });
+  return result;
+};
+var findTrRow = (children) => {
+  let result = null;
+  Children.forEach(children, (child) => {
+    if (isValidElement(child)) {
+      if (child.type === TableRow || child.type?.displayName === "TableRow") {
+        result = child;
+      }
+    }
+  });
+  return result;
+};
+var ALIGN_CLASSES2 = {
+  center: "nexus-td--center",
+  left: "nexus-td--left",
+  right: "nexus-td--right"
+};
+var DefaultNoData = () => /* @__PURE__ */ jsx("div", { className: "nexus-table-center nexus-table-nodata", children: "No data available." });
+var DefaultLoading = () => /* @__PURE__ */ jsx("div", { className: "nexus-table-center", children: /* @__PURE__ */ jsx("div", { className: "nexus-table-loading-icon" }) });
+function Table({
+  className = "",
+  theadClassName = "",
+  list,
+  children,
+  loadingElement,
+  noDataMsg,
+  hideThead,
+  sortUpElement = /* @__PURE__ */ jsx(DefaultSortIcon, { direction: "asc" }),
+  sortDownElement = /* @__PURE__ */ jsx(DefaultSortIcon, { direction: "desc" }),
+  loadingType = "skeleton",
+  loading,
+  skeletonCount = 10,
+  notification
+}) {
+  const [isSorting, setIsSorting] = useState(false);
+  const [orderData, setOrderData] = useState(null);
+  const tdColumns = useMemo(() => {
+    const item = (list || []).length > 0 ? list?.[0] : {};
+    return findTdColumns(children({ item, index: 0 }));
+  }, [children, list]);
+  const trRow = useMemo(() => {
+    const item = (list || []).length > 0 ? list?.[0] : {};
+    return findTrRow(children({ item, index: 0 }));
+  }, [children, list]);
+  const thRowData = useMemo(() => {
+    const thRows = tdColumns?.map((column) => {
+      const component = column;
+      const tdClassName = component?.props?.className;
+      const widthClassName = tdClassName?.match(
+        /(fold:|mobile-sm:|tablet:|desktop-sm:|desktop:|desktop-lg:|wide-desktop:|xs:|sm:|md:|lg:|xl:|2xl:)?(w-\[[0-9]+(\.[0-9]+)?px\]|w-full|w-\d+\/\d+|w-\d+|min-w-[^\s"]+|max-w-[^\s"]+)/g
+      );
+      return {
+        className: component.props?.className ?? "",
+        label: component.props?.label ?? "",
+        fieldId: component.props?.fieldId,
+        enableSorting: typeof component.props?.sortValue !== "undefined" || !!component.props?.handleClickSort,
+        handleClickSort: component.props?.handleClickSort,
+        thColSpan: component.props?.thColSpan,
+        thRowSpan: component.props?.thRowSpan,
+        rowSpan: component.props?.rowSpan,
+        colSpan: component.props?.colSpan,
+        size: component.props?.size,
+        widthClassName: widthClassName && widthClassName.join(" "),
+        align: component.props?.align ?? "left",
+        order: component.props?.order ?? ""
+      };
+    });
+    if (thRows) {
+      return thRows.filter((th) => typeof th.label !== "undefined").map((th) => {
+        if (!orderData?.fieldId) return th;
+        return {
+          ...th,
+          order: orderData.fieldId === th.fieldId ? orderData.order : ""
+        };
+      });
+    }
+    return [];
+  }, [tdColumns, orderData]);
+  const skeletonRows = useMemo(() => {
+    const trRowComponent = trRow;
+    return Array.from({ length: skeletonCount }, (_, trIndex) => /* @__PURE__ */ jsx(
+      "tr",
+      {
+        className: cn(trRowComponent?.props?.className, "nexus-table-skeleton-row"),
+        children: thRowData?.map((thData, tdIndex) => /* @__PURE__ */ jsx(
+          "td",
+          {
+            className: cn(thData.widthClassName, "nexus-table-skeleton-td"),
+            style: thData.size ? {
+              width: typeof thData.size === "number" ? `${thData.size}px` : thData.size,
+              flex: `0 0 ${typeof thData.size === "number" ? `${thData.size}px` : thData.size}`
+            } : void 0,
+            children: /* @__PURE__ */ jsx(Skeleton, { className: "nexus-table-skeleton-bar" })
+          },
+          `skeleton-td-${tdIndex}`
+        ))
+      },
+      `skeleton-tr-${trIndex}`
+    ));
+  }, [skeletonCount, thRowData, trRow]);
+  const tableRows = useMemo(() => {
+    const { fieldId: orderTargetFieldId, order } = orderData ?? {};
+    if (!order) return list;
+    const componentList = list?.map(
+      (item, index) => Children.map(
+        children({ item, index }),
+        (child) => {
+          if (isValidElement(child)) {
+            if (child.type === TdColumn) return child;
+            return Children.toArray(child.props.children);
+          }
+          return [];
+        }
+      )
+    );
+    const sortValueList = componentList?.reduce((acc, cur) => {
+      const columns = cur;
+      const target = columns?.find((col) => col?.props?.fieldId === orderTargetFieldId);
+      acc.push(target?.props?.sortValue ?? 0);
+      return acc;
+    }, []);
+    return orderBy(
+      list?.map((item, index) => ({ ...item, sortValue: sortValueList?.[index] })),
+      ["sortValue"],
+      [order]
+    );
+  }, [list, orderData, children]);
+  const handleThSorting = async (thData) => {
+    let newOrder = "desc";
+    const { order, index, fieldId, enableSorting, handleClickSort } = thData;
+    if (!enableSorting || isSorting) return;
+    if (order === "desc") newOrder = "asc";
+    else if (order === "asc") newOrder = "";
+    const newOrderData = { index, order: newOrder, fieldId: fieldId ?? "" };
+    setOrderData(newOrderData);
+    if (handleClickSort) {
+      try {
+        setIsSorting(true);
+        await handleClickSort(newOrderData);
+      } finally {
+        setIsSorting(false);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsx(TableHighlightProvider, { children: /* @__PURE__ */ jsx("div", { className: cn("nexus-table-wrap", className), children: /* @__PURE__ */ jsxs("table", { className: "nexus-table", children: [
+    !hideThead && /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { className: cn("nexus-table-thead", theadClassName), children: thRowData.map((thData, index) => /* @__PURE__ */ jsx(
+      "th",
+      {
+        rowSpan: thData.thRowSpan ?? thData.rowSpan,
+        colSpan: thData.thColSpan ?? thData.colSpan,
+        className: cn(
+          "nexus-table-th",
+          thData.enableSorting && "nexus-table-th--sortable",
+          ALIGN_CLASSES2[thData.align ?? "left"],
+          thData.widthClassName
+        ),
+        style: thData.size ? {
+          width: typeof thData.size === "number" ? `${thData.size}px` : thData.size,
+          flex: `0 0 ${typeof thData.size === "number" ? `${thData.size}px` : thData.size}`
+        } : void 0,
+        children: thData.enableSorting ? /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "nexus-table-th__sort-btn",
+            onClick: () => handleThSorting({ ...thData, index }),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                handleThSorting({ ...thData, index });
+              }
+            },
+            "aria-label": `Sort by ${thData.label}${thData.order === "asc" ? ", ascending" : thData.order === "desc" ? ", descending" : ""}`,
+            children: [
+              thData.label,
+              /* @__PURE__ */ jsxs("span", { children: [
+                thData.order !== "desc" && thData.order !== "asc" && /* @__PURE__ */ jsx(DefaultSortIcon, { direction: "default" }),
+                thData.order === "desc" && sortDownElement,
+                thData.order === "asc" && sortUpElement
+              ] })
+            ]
+          }
+        ) : thData.label
+      },
+      `th-${thData.fieldId ?? index}`
+    )) }) }),
+    notification && /* @__PURE__ */ jsx("tbody", { children: /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: thRowData.length || 1, children: notification }) }) }),
+    /* @__PURE__ */ jsxs("tbody", { children: [
+      (!list || isSorting || loading) && (loadingType === "loading" ? /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: thRowData.length, children: /* @__PURE__ */ jsx("div", { children: loadingElement ?? /* @__PURE__ */ jsx(DefaultLoading, {}) }) }) }) : /* @__PURE__ */ jsx(Fragment, { children: skeletonRows })),
+      !!list && !loading && !isSorting && (list.length > 0 ? tableRows?.map(
+        (item, index) => children({ item, index })
+      ) : /* @__PURE__ */ jsx("tr", { children: /* @__PURE__ */ jsx("td", { colSpan: thRowData.length, children: noDataMsg && typeof noDataMsg === "object" ? noDataMsg : /* @__PURE__ */ jsx(DefaultNoData, {}) }) }))
+    ] })
+  ] }) }) });
+}
+
+export { Table, TableHighlightProvider, TableRow, TdColumn, tableRowVariants, useTableHighlight };

package/dist/chunks/chunk-HUPAHDJ7.js

@@ -0,0 +1,273 @@
+'use strict';
+
+var react = require('react');
+var lodashEs = require('lodash-es');
+
+// src/hooks/useModal.ts
+
+// src/modal/constants.ts
+var defaultModalOption = {
+  animation: { name: "pop-fade", duration: 300 },
+  dimCloseEnable: true
+};
+
+// src/modal/Modal.ts
+var Modal = class {
+  constructor() {
+    this._modalList = [];
+    this.defaultOption = { ...defaultModalOption };
+    this.observeFunction = null;
+    this.enableKeyDownEvent = true;
+    this.handleKeyPressEvent = (e) => {
+      if (e.code === "Escape" && this.enableKeyDownEvent) {
+        const lastModal = this.modalList[this.modalList.length - 1];
+        if (!lastModal.props.disableEscapeKeyPress) {
+          this.closeModal(lastModal.id, true);
+        }
+      }
+    };
+  }
+  set modalList(value) {
+    const newModalList = [...value];
+    this._modalList = newModalList;
+    this.observeFunction?.(newModalList);
+    if (newModalList.length === 1) {
+      window.addEventListener("keyup", this.handleKeyPressEvent);
+    } else if (newModalList.length === 0) {
+      window.removeEventListener("keyup", this.handleKeyPressEvent);
+    }
+  }
+  get modalList() {
+    return this._modalList;
+  }
+  checkModal(params) {
+    const { onlyLastCheck } = params;
+    const modalLength = this.modalList.length;
+    if ("componentName" in params) {
+      const { componentName } = params;
+      if (onlyLastCheck) {
+        return modalLength > 0 && !!componentName ? this.modalList[modalLength - 1].props.componentName === componentName : false;
+      }
+      return this.modalList.some(
+        (m) => m.props.componentName === componentName
+      );
+    } else {
+      const { modalId } = params;
+      if (onlyLastCheck) {
+        return modalLength > 0 && !!modalId ? this.modalList[modalLength - 1].props.id === modalId : false;
+      }
+      return this.modalList.some((m) => m.props.id === modalId);
+    }
+  }
+  deleteModal(id) {
+    const findModal = this.modalList.find((m) => m.id === id);
+    if (!findModal) return;
+    const newModalList = this.modalList.filter((m) => m.id !== id);
+    this.modalList = newModalList;
+    findModal.props.onClose?.();
+  }
+  closeModal(id, isAnimation = true) {
+    const findModal = this.modalList.find((m) => m.id === id);
+    if (findModal) {
+      if (findModal.close) {
+        findModal.close(findModal.id, isAnimation);
+      } else {
+        this.deleteModal(id);
+      }
+    }
+  }
+  resolveModal({
+    modal: modal2,
+    result,
+    useClose
+  }) {
+    modal2.resolve(result);
+    if (useClose) {
+      this.closeModal(modal2.id);
+    }
+  }
+  resetModal() {
+    this.modalList = [];
+  }
+  makeProps(props) {
+    return {
+      ...props || {},
+      animation: {
+        ...this.defaultOption.animation,
+        ...props?.animation || {}
+      }
+    };
+  }
+  handleToggle(modal2) {
+    const modalList = [...this.modalList];
+    const findModal = modalList.find(
+      (m) => m.component.name === modal2.component.name
+    );
+    if (findModal) {
+      if (findModal.close) {
+        findModal.close(findModal.id, true);
+      } else {
+        this.deleteModal(findModal.id);
+      }
+      return null;
+    }
+    return [...modalList, modal2];
+  }
+  handleToggleOnlyOne(modal2) {
+    const modalList = [...this.modalList];
+    const findModal = modalList.find(
+      (m) => m.component.name === modal2.component.name
+    );
+    if (findModal) {
+      if (findModal.close) {
+        findModal.close(findModal.id, true);
+      } else {
+        this.deleteModal(findModal.id);
+      }
+      return [];
+    }
+    return [modal2];
+  }
+  openModal({
+    component,
+    props
+  }) {
+    return new Promise((resolve, reject) => {
+      const modal2 = {
+        id: "",
+        props: props ?? {},
+        component,
+        resolve,
+        reject
+      };
+      const prevModalList = [...this.modalList];
+      const componentName = props?.componentName ?? component.displayName ?? component.name;
+      modal2.id = props?.id || props?.portalId || lodashEs.uniqueId();
+      modal2.props = this.makeProps({
+        ...props ?? {},
+        componentName
+      });
+      let newModalList = [...prevModalList, modal2];
+      if (modal2.props.isToggle && modal2.props.isAlone) {
+        newModalList = this.handleToggleOnlyOne(modal2);
+      } else if (modal2.props.isToggle) {
+        newModalList = this.handleToggle(modal2);
+      } else if (modal2.props.isAlone) {
+        newModalList = [modal2];
+      }
+      if (!modal2.props.isToggle && !modal2.props.isAlone) {
+        let duplicate = props?.id || props?.portalId ? this.checkModal({ modalId: modal2.id, onlyLastCheck: true }) : this.checkModal({ componentName, onlyLastCheck: true });
+        if (props?.duplicateCheck) {
+          duplicate = props?.id || props?.portalId ? this.checkModal({ modalId: modal2.id }) : this.checkModal({ componentName });
+        }
+        if (duplicate) return;
+      }
+      if (newModalList) {
+        this.enableKeyDownEvent = false;
+        this.modalList = newModalList;
+        setTimeout(() => {
+          this.enableKeyDownEvent = true;
+        }, 500);
+      }
+      if (modal2.props.onOpen) {
+        modal2.props.onOpen({ ...modal2 });
+      }
+    });
+  }
+  getDefaultOption() {
+    return this.defaultOption;
+  }
+  observe({
+    options = {},
+    observeFunction
+  }) {
+    this.defaultOption = { ...defaultModalOption, ...options };
+    this.observeFunction = observeFunction;
+    if (this._modalList.length > 0) {
+      this.observeFunction(this._modalList);
+    }
+  }
+  unobserve() {
+    this.observeFunction = null;
+    this.defaultOption = {};
+  }
+};
+var modal = new Modal();
+var Modal_default = modal;
+
+// src/hooks/useModal.ts
+function callOpenModal(params, extraOptions) {
+  const { component, props = {}, options = {} } = params;
+  return Modal_default.openModal({
+    component,
+    props: {
+      ...props,
+      ...options,
+      ...extraOptions
+    }
+  });
+}
+function useModal() {
+  const modal2 = react.useMemo(() => {
+    const fn = ((params) => callOpenModal(params));
+    fn.close = (id, isAnimation) => {
+      Modal_default.closeModal(id, isAnimation);
+    };
+    fn.check = (params) => {
+      return Modal_default.checkModal(params);
+    };
+    fn.reset = () => {
+      Modal_default.resetModal();
+    };
+    return fn;
+  }, []);
+  const toggleModal = react.useCallback(
+    (params) => {
+      return callOpenModal(params, {
+        scrollEnable: params.options?.scrollEnable ?? true,
+        isToggle: true
+      });
+    },
+    []
+  );
+  const toggleOneModal = react.useCallback(
+    (params) => {
+      return callOpenModal(params, {
+        scrollEnable: params.options?.scrollEnable ?? true,
+        isToggle: true,
+        isAlone: true
+      });
+    },
+    []
+  );
+  const scrollModal = react.useCallback(
+    (params) => {
+      return callOpenModal(params, { scrollEnable: true });
+    },
+    []
+  );
+  const closeModal = react.useCallback((id, isAnimation) => {
+    Modal_default.closeModal(id, isAnimation);
+  }, []);
+  const checkModal = react.useCallback(
+    (params) => {
+      return Modal_default.checkModal(params);
+    },
+    []
+  );
+  const resetModal = react.useCallback(() => {
+    Modal_default.resetModal();
+  }, []);
+  return {
+    modal: modal2,
+    toggleModal,
+    toggleOneModal,
+    scrollModal,
+    closeModal,
+    checkModal,
+    resetModal
+  };
+}
+
+exports.Modal_default = Modal_default;
+exports.useModal = useModal;

package/dist/chunks/chunk-I252NERB.mjs

@@ -0,0 +1,21 @@
+import { __require } from './chunk-CVYXRSXT.mjs';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+var ThemeProvider = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children });
+var useTheme = () => ({
+  theme: void 0,
+  setTheme: () => {
+  },
+  resolvedTheme: void 0,
+  themes: [],
+  systemTheme: void 0,
+  forcedTheme: void 0
+});
+try {
+  const nextThemes = __require("next-themes");
+  ThemeProvider = nextThemes.ThemeProvider;
+  useTheme = nextThemes.useTheme;
+} catch {
+}
+
+export { ThemeProvider, useTheme };

package/dist/chunks/chunk-IE4DGLMH.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var TooltipPrimitive = require('@radix-ui/react-tooltip');
+var classVarianceAuthority = require('class-variance-authority');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var TooltipPrimitive__namespace = /*#__PURE__*/_interopNamespace(TooltipPrimitive);
+
+var tooltipContentVariants = classVarianceAuthority.cva("nexus-tooltip-content", {
+  variants: {
+    variant: {
+      light: "nexus-tooltip--light",
+      dark: "nexus-tooltip--dark"
+    }
+  },
+  defaultVariants: { variant: "dark" }
+});
+var TooltipProvider = TooltipPrimitive__namespace.Provider;
+var Tooltip = ({
+  children,
+  content,
+  side = "top",
+  align = "center",
+  delayDuration = 200,
+  disabled = false,
+  variant = "dark",
+  triggerClassName = "",
+  className = ""
+}) => {
+  if (disabled) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  return /* @__PURE__ */ jsxRuntime.jsx(TooltipProvider, { delayDuration, children: /* @__PURE__ */ jsxRuntime.jsxs(TooltipPrimitive__namespace.Root, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(TooltipPrimitive__namespace.Trigger, { asChild: true, className: chunkCZC76ZD5_js.cn("nexus-tooltip-trigger", triggerClassName), children: /* @__PURE__ */ jsxRuntime.jsx("span", { children }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(TooltipPrimitive__namespace.Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+      TooltipPrimitive__namespace.Content,
+      {
+        side,
+        align,
+        className: chunkCZC76ZD5_js.cn(tooltipContentVariants({ variant }), className),
+        sideOffset: 4,
+        children: [
+          content,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            TooltipPrimitive__namespace.Arrow,
+            {
+              className: variant === "dark" ? "nexus-tooltip-arrow--dark" : "nexus-tooltip-arrow--light"
+            }
+          )
+        ]
+      }
+    ) })
+  ] }) });
+};
+
+exports.Tooltip = Tooltip;
+exports.TooltipProvider = TooltipProvider;
+exports.tooltipContentVariants = tooltipContentVariants;