@nexus-cross/design-system 1.0.0

package/dist/chunks/chunk-MTX7GD3H.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var chunkEVOOTSY5_js = require('./chunk-EVOOTSY5.js');
+var chunkIOSIQLZL_js = require('./chunk-IOSIQLZL.js');
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var React = require('react');
+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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function DataList({
+  list,
+  loadingElement,
+  skeletonElement,
+  skeletonCount = 3,
+  noDataMessage,
+  loading = false,
+  errorFallback,
+  children,
+  className
+}) {
+  const content = React__namespace.useMemo(() => {
+    if (!list || loading) {
+      if (skeletonElement) {
+        return Array.from({ length: skeletonCount }).map(
+          (_, index) => React__namespace.cloneElement(skeletonElement, {
+            ...skeletonElement.props,
+            key: index
+          })
+        );
+      }
+      return loadingElement ?? /* @__PURE__ */ jsxRuntime.jsx("div", { className: chunkCZC76ZD5_js.cn("nexus-datalist-center"), children: /* @__PURE__ */ jsxRuntime.jsx(chunkIOSIQLZL_js.Spinner, { size: 32 }) });
+    }
+    if (list.length === 0) {
+      if (React__namespace.isValidElement(noDataMessage)) {
+        return noDataMessage;
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "p",
+        {
+          className: chunkCZC76ZD5_js.cn("nexus-datalist-empty"),
+          children: noDataMessage ?? "\uB370\uC774\uD130\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4"
+        }
+      );
+    }
+    return list.map(
+      (item, index) => children({ item, index })
+    );
+  }, [
+    list,
+    loading,
+    skeletonElement,
+    skeletonCount,
+    loadingElement,
+    noDataMessage,
+    children
+  ]);
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkEVOOTSY5_js.ErrorBoundary, { fallback: errorFallback, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: content }) });
+}
+DataList.displayName = "DataList";
+
+exports.DataList = DataList;

package/dist/chunks/chunk-NFIPQZ4O.js

@@ -0,0 +1,100 @@
+'use strict';
+
+var React = require('react');
+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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/components/Counter.tsx
+function easeOutCubic(t) {
+  return 1 - Math.pow(1 - t, 3);
+}
+function formatNumber(val, separator, digits) {
+  const fixed = digits > 0 ? val.toFixed(digits) : Math.round(val).toString();
+  if (!separator) return fixed;
+  const [intPart, decPart] = fixed.split(".");
+  const formatted = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return decPart !== void 0 ? `${formatted}.${decPart}` : formatted;
+}
+var Counter = React__namespace.forwardRef(
+  ({
+    startValue = 0,
+    endValue,
+    duration = 1500,
+    delay = 0,
+    separator = true,
+    digits = 0,
+    triggerOnView = false,
+    onEnd,
+    className,
+    ...props
+  }, ref) => {
+    const [display, setDisplay] = React__namespace.useState(formatNumber(startValue, separator, digits));
+    const [started, setStarted] = React__namespace.useState(!triggerOnView);
+    const innerRef = React__namespace.useRef(null);
+    React__namespace.useImperativeHandle(ref, () => innerRef.current);
+    React__namespace.useEffect(() => {
+      if (!triggerOnView || !innerRef.current) return;
+      const observer = new IntersectionObserver(
+        ([entry]) => {
+          if (entry.isIntersecting) {
+            setStarted(true);
+            observer.disconnect();
+          }
+        },
+        { threshold: 0.1 }
+      );
+      observer.observe(innerRef.current);
+      return () => observer.disconnect();
+    }, [triggerOnView]);
+    React__namespace.useEffect(() => {
+      if (!started) return;
+      let rafId;
+      let startTime = null;
+      const delayMs = delay;
+      const timeout = setTimeout(() => {
+        const animate = (timestamp) => {
+          if (startTime === null) startTime = timestamp;
+          const elapsed = timestamp - startTime;
+          const progress = Math.min(elapsed / duration, 1);
+          const eased = easeOutCubic(progress);
+          const current = startValue + (endValue - startValue) * eased;
+          setDisplay(formatNumber(current, separator, digits));
+          if (progress < 1) {
+            rafId = requestAnimationFrame(animate);
+          } else {
+            setDisplay(formatNumber(endValue, separator, digits));
+            onEnd?.();
+          }
+        };
+        rafId = requestAnimationFrame(animate);
+      }, delayMs);
+      return () => {
+        clearTimeout(timeout);
+        if (rafId) cancelAnimationFrame(rafId);
+      };
+    }, [started, startValue, endValue, duration, delay, separator, digits, onEnd]);
+    return /* @__PURE__ */ jsxRuntime.jsx("span", { ref: innerRef, className, role: "status", "aria-live": "polite", "aria-atomic": true, ...props, children: display });
+  }
+);
+Counter.displayName = "Counter";
+
+exports.Counter = Counter;

package/dist/chunks/chunk-NHDGKOAM.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useDraggableWindow.ts
+function useDraggableWindow({
+  initialPosition,
+  persistKey,
+  targetRef
+} = {}) {
+  const [position, setPosition] = react.useState(() => {
+    if (persistKey) {
+      try {
+        const saved = localStorage.getItem(`draggable-${persistKey}`);
+        if (saved) return JSON.parse(saved);
+      } catch {
+      }
+    }
+    return initialPosition ?? { x: -1, y: -1 };
+  });
+  const dragRef = react.useRef({
+    isDragging: false,
+    startX: 0,
+    startY: 0,
+    startPosX: 0,
+    startPosY: 0
+  });
+  const handleMouseDown = react.useCallback(
+    (e) => {
+      if (e.target.closest("button, input, select, textarea"))
+        return;
+      e.preventDefault();
+      let startPosX = position.x;
+      let startPosY = position.y;
+      if (startPosX === -1 && startPosY === -1 && targetRef?.current) {
+        const rect = targetRef.current.getBoundingClientRect();
+        startPosX = rect.left;
+        startPosY = rect.top;
+        setPosition({ x: startPosX, y: startPosY });
+      }
+      dragRef.current = {
+        isDragging: true,
+        startX: e.clientX,
+        startY: e.clientY,
+        startPosX,
+        startPosY
+      };
+      const handleMouseMove = (ev) => {
+        if (!dragRef.current.isDragging) return;
+        const dx = ev.clientX - dragRef.current.startX;
+        const dy = ev.clientY - dragRef.current.startY;
+        const newX = Math.max(
+          0,
+          Math.min(window.innerWidth - 100, dragRef.current.startPosX + dx)
+        );
+        const newY = Math.max(
+          0,
+          Math.min(window.innerHeight - 40, dragRef.current.startPosY + dy)
+        );
+        setPosition({ x: newX, y: newY });
+      };
+      const handleMouseUp = () => {
+        dragRef.current.isDragging = false;
+        document.removeEventListener("mousemove", handleMouseMove);
+        document.removeEventListener("mouseup", handleMouseUp);
+        document.body.style.cursor = "";
+        document.body.style.userSelect = "";
+        if (persistKey) {
+          setPosition((pos) => {
+            try {
+              localStorage.setItem(
+                `draggable-${persistKey}`,
+                JSON.stringify(pos)
+              );
+            } catch {
+            }
+            return pos;
+          });
+        }
+      };
+      document.body.style.cursor = "grabbing";
+      document.body.style.userSelect = "none";
+      document.addEventListener("mousemove", handleMouseMove);
+      document.addEventListener("mouseup", handleMouseUp);
+    },
+    [position, persistKey, targetRef]
+  );
+  const resetPosition = react.useCallback(() => {
+    const reset = initialPosition ?? { x: -1, y: -1 };
+    setPosition(reset);
+    if (persistKey) {
+      localStorage.removeItem(`draggable-${persistKey}`);
+    }
+  }, [initialPosition, persistKey]);
+  return {
+    position,
+    setPosition,
+    handleMouseDown,
+    resetPosition,
+    isDefaultPosition: position.x === -1 && position.y === -1
+  };
+}
+
+exports.useDraggableWindow = useDraggableWindow;

package/dist/chunks/chunk-OMN5YQCE.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var React = require('react');
+var reactVirtual = require('@tanstack/react-virtual');
+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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+function VirtualListInner({
+  items,
+  estimateSize,
+  renderItem,
+  overscan = 5,
+  gap = 0,
+  className,
+  style,
+  onEndReached,
+  endReachedThreshold = 200
+}, ref) {
+  const parentRef = React__namespace.useRef(null);
+  React__namespace.useImperativeHandle(ref, () => parentRef.current);
+  const estimateFn = typeof estimateSize === "function" ? estimateSize : () => estimateSize;
+  const onEndReachedRef = React__namespace.useRef(onEndReached);
+  onEndReachedRef.current = onEndReached;
+  const virtualizer = reactVirtual.useVirtualizer({
+    count: items.length,
+    getScrollElement: () => parentRef.current,
+    estimateSize: estimateFn,
+    overscan,
+    gap
+  });
+  React__namespace.useEffect(() => {
+    const el = parentRef.current;
+    if (!el || !onEndReachedRef.current) return;
+    const handleScroll = () => {
+      const { scrollTop, scrollHeight, clientHeight } = el;
+      if (scrollHeight - scrollTop - clientHeight < endReachedThreshold) {
+        onEndReachedRef.current?.();
+      }
+    };
+    el.addEventListener("scroll", handleScroll, { passive: true });
+    return () => el.removeEventListener("scroll", handleScroll);
+  }, [endReachedThreshold]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: parentRef, className: chunkCZC76ZD5_js.cn("nexus-virtual-scroll", className), style, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { height: virtualizer.getTotalSize(), width: "100%", position: "relative" }, children: virtualizer.getVirtualItems().map((virtualItem) => /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: virtualItem.size,
+        transform: `translateY(${virtualItem.start}px)`
+      },
+      children: renderItem(items[virtualItem.index], virtualItem.index, virtualItem)
+    },
+    virtualItem.key
+  )) }) });
+}
+var VirtualList = React__namespace.forwardRef(VirtualListInner);
+function VirtualGridInner({
+  items,
+  columns,
+  estimateSize,
+  renderItem,
+  overscan = 3,
+  gap = 0,
+  className,
+  style,
+  onEndReached,
+  endReachedThreshold = 200
+}, ref) {
+  const parentRef = React__namespace.useRef(null);
+  React__namespace.useImperativeHandle(ref, () => parentRef.current);
+  const rowCount = Math.ceil(items.length / columns);
+  const estimateFn = typeof estimateSize === "function" ? estimateSize : () => estimateSize;
+  const onEndReachedRef = React__namespace.useRef(onEndReached);
+  onEndReachedRef.current = onEndReached;
+  const virtualizer = reactVirtual.useVirtualizer({
+    count: rowCount,
+    getScrollElement: () => parentRef.current,
+    estimateSize: estimateFn,
+    overscan,
+    gap
+  });
+  React__namespace.useEffect(() => {
+    const el = parentRef.current;
+    if (!el || !onEndReachedRef.current) return;
+    const handleScroll = () => {
+      const { scrollTop, scrollHeight, clientHeight } = el;
+      if (scrollHeight - scrollTop - clientHeight < endReachedThreshold) {
+        onEndReachedRef.current?.();
+      }
+    };
+    el.addEventListener("scroll", handleScroll, { passive: true });
+    return () => el.removeEventListener("scroll", handleScroll);
+  }, [endReachedThreshold]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: parentRef, className: chunkCZC76ZD5_js.cn("nexus-virtual-scroll", className), style, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { height: virtualizer.getTotalSize(), width: "100%", position: "relative" }, children: virtualizer.getVirtualItems().map((virtualRow) => {
+    const rowStart = virtualRow.index * columns;
+    const rowItems = items.slice(rowStart, rowStart + columns);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          top: 0,
+          left: 0,
+          width: "100%",
+          height: virtualRow.size,
+          transform: `translateY(${virtualRow.start}px)`,
+          display: "grid",
+          gridTemplateColumns: `repeat(${columns}, 1fr)`,
+          gap
+        },
+        children: rowItems.map((item, colIdx) => /* @__PURE__ */ jsxRuntime.jsx("div", { children: renderItem(item, rowStart + colIdx) }, rowStart + colIdx))
+      },
+      virtualRow.key
+    );
+  }) }) });
+}
+var VirtualGrid = React__namespace.forwardRef(VirtualGridInner);
+
+exports.VirtualGrid = VirtualGrid;
+exports.VirtualList = VirtualList;

package/dist/chunks/chunk-OTGS6BDQ.mjs

@@ -0,0 +1,25 @@
+import { useEffect } from 'react';
+
+// src/hooks/useClickOutside.ts
+var useClickOutside = (ref, handler, option) => {
+  useEffect(() => {
+    const listener = (event) => {
+      const el = ref && "current" in ref ? ref.current : ref;
+      if (!el || el.contains(event.target)) {
+        return;
+      }
+      handler(event);
+    };
+    document.addEventListener("click", listener);
+    if (!option?.offTouchEvent) {
+      document.addEventListener("touchstart", listener);
+    }
+    return () => {
+      document.removeEventListener("click", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, [ref, handler, option]);
+};
+var useClickOutside_default = useClickOutside;
+
+export { useClickOutside_default };

package/dist/chunks/chunk-P2T72N62.mjs

@@ -0,0 +1,34 @@
+import { cn } from './chunk-MCKOWMLS.mjs';
+import * as React from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var Skeleton = React.forwardRef(
+  ({
+    className,
+    children,
+    as: Tag = "div",
+    circle = false,
+    width,
+    height,
+    style,
+    ...props
+  }, ref) => /* @__PURE__ */ jsx(
+    Tag,
+    {
+      ref,
+      role: "status",
+      "aria-label": "Loading",
+      className: cn(
+        "nexus-skeleton",
+        circle ? "nexus-skeleton--circle" : "nexus-skeleton--rect",
+        className
+      ),
+      style: { width, height, ...style },
+      ...props,
+      children: children && /* @__PURE__ */ jsx("span", { className: "nexus-skeleton__children", children })
+    }
+  )
+);
+Skeleton.displayName = "Skeleton";
+
+export { Skeleton };

package/dist/chunks/chunk-P3DZKXG4.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var React = require('react');
+var reactSlot = require('@radix-ui/react-slot');
+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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+var buttonVariants = classVarianceAuthority.cva("nexus-btn", {
+  variants: {
+    semantic: {
+      primary: "nexus-btn--primary",
+      secondary: "nexus-btn--secondary",
+      normal: "nexus-btn--normal",
+      danger: "nexus-btn--danger"
+    },
+    variant: {
+      contained: "nexus-btn--contained",
+      outlined: "nexus-btn--outlined",
+      subtle: "nexus-btn--subtle",
+      ghost: "nexus-btn--ghost"
+    },
+    size: {
+      xl: "nexus-btn--xl",
+      lg: "nexus-btn--lg",
+      md: "nexus-btn--md",
+      sm: "nexus-btn--sm"
+    },
+    radius: {
+      default: "",
+      circle: "nexus-btn--circle"
+    }
+  },
+  defaultVariants: {
+    semantic: "primary",
+    variant: "contained",
+    size: "md",
+    radius: "default"
+  }
+});
+var Button = React__namespace.forwardRef(
+  ({
+    className,
+    semantic,
+    variant,
+    size,
+    radius,
+    asChild = false,
+    detectDoubleClick = false,
+    disabled,
+    children,
+    onClick,
+    style,
+    ...props
+  }, ref) => {
+    const clickTimeoutRef = React__namespace.useRef(
+      null
+    );
+    const handleClick = React__namespace.useCallback(
+      (e) => {
+        if (detectDoubleClick && clickTimeoutRef.current) return;
+        onClick?.(e);
+        if (detectDoubleClick) {
+          clickTimeoutRef.current = setTimeout(() => {
+            clickTimeoutRef.current = null;
+          }, 500);
+        }
+      },
+      [detectDoubleClick, onClick]
+    );
+    const Comp = asChild ? reactSlot.Slot : "button";
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Comp,
+      {
+        ref,
+        type: asChild ? void 0 : "button",
+        role: asChild ? "button" : void 0,
+        className: chunkCZC76ZD5_js.cn(
+          buttonVariants({ semantic, variant, size, radius }),
+          className
+        ),
+        disabled: asChild ? void 0 : disabled,
+        "aria-disabled": disabled || void 0,
+        tabIndex: disabled ? -1 : void 0,
+        onClick: disabled ? void 0 : handleClick,
+        style,
+        ...props,
+        children
+      }
+    );
+  }
+);
+Button.displayName = "Button";
+
+exports.Button = Button;
+exports.buttonVariants = buttonVariants;

package/dist/chunks/chunk-QK6NCII4.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var React = require('react');
+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 React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+// src/components/ClientOnly.tsx
+function ClientOnly({ children, fallback = null }) {
+  const [mounted, setMounted] = React__namespace.useState(false);
+  React__namespace.useEffect(() => {
+    setMounted(true);
+  }, []);
+  return mounted ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children }) : /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+}
+ClientOnly.displayName = "ClientOnly";
+
+exports.ClientOnly = ClientOnly;