@nexus-cross/design-system 1.0.0

package/dist/chunks/chunk-AFSEYJZT.js

@@ -0,0 +1,267 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var React = require('react');
+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 numberInputVariants = classVarianceAuthority.cva("nexus-number-input", {
+  variants: {
+    size: {
+      sm: "nexus-number-input--sm",
+      md: "nexus-number-input--md",
+      lg: "nexus-number-input--lg",
+      xl: "nexus-number-input--xl"
+    },
+    state: {
+      default: "nexus-number-input--default",
+      error: "nexus-number-input--error"
+    }
+  },
+  defaultVariants: { size: "md", state: "default" }
+});
+var ChevronUp = () => /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "nexus-number-input__step-icon", viewBox: "0 0 12 12", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 7.5L6 4.5l3 3" }) });
+var ChevronDown = () => /* @__PURE__ */ jsxRuntime.jsx("svg", { className: "nexus-number-input__step-icon", viewBox: "0 0 12 12", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 4.5L6 7.5l3-3" }) });
+function clampValue(val, min, max) {
+  let result = val;
+  if (min !== void 0) result = Math.max(min, result);
+  if (max !== void 0) result = Math.min(max, result);
+  return result;
+}
+function roundToDigit(val, digit) {
+  const factor = Math.pow(10, digit);
+  return Math.round(val * factor) / factor;
+}
+function numberInputBind(ref, direction) {
+  return {
+    onPointerDown: (e) => {
+      if (direction === "increment") ref.current?.startIncrement(e);
+      else ref.current?.startDecrement(e);
+    },
+    onPointerUp: () => ref.current?.stop(),
+    onPointerLeave: () => ref.current?.stop()
+  };
+}
+var NumberInput = React__namespace.forwardRef(
+  ({
+    className,
+    size,
+    error,
+    value,
+    min,
+    max,
+    step = 1,
+    digit = 0,
+    hideButtons = false,
+    disabled,
+    readOnly,
+    onValueChange,
+    placeholder,
+    ...props
+  }, ref) => {
+    const inputRef = React__namespace.useRef(null);
+    const state = error ? "error" : "default";
+    const [internalValue, setInternalValue] = React__namespace.useState(value?.toString() ?? "");
+    const internalValueRef = React__namespace.useRef(internalValue);
+    const timeoutRef = React__namespace.useRef(null);
+    const pressCountRef = React__namespace.useRef(0);
+    React__namespace.useEffect(() => {
+      internalValueRef.current = internalValue;
+    }, [internalValue]);
+    React__namespace.useEffect(() => {
+      setInternalValue(value?.toString() ?? "");
+    }, [value]);
+    const commitValue = React__namespace.useCallback(
+      (raw) => {
+        if (raw === "" || raw === "-") {
+          setInternalValue(raw);
+          onValueChange?.(void 0);
+          return;
+        }
+        const parsed = parseFloat(raw);
+        if (isNaN(parsed)) return;
+        const clamped = clampValue(roundToDigit(parsed, digit), min, max);
+        setInternalValue(clamped.toString());
+        onValueChange?.(clamped);
+      },
+      [digit, min, max, onValueChange]
+    );
+    const handleInputChange = React__namespace.useCallback(
+      (e) => {
+        const raw = e.target.value;
+        const regex = digit > 0 ? /^-?\d*\.?\d*$/ : /^-?\d*$/;
+        if (!regex.test(raw)) return;
+        setInternalValue(raw);
+      },
+      [digit]
+    );
+    const handleBlur = React__namespace.useCallback(() => {
+      commitValue(internalValue);
+    }, [internalValue, commitValue]);
+    const adjust = React__namespace.useCallback(
+      (delta) => {
+        const current = parseFloat(internalValueRef.current) || 0;
+        const next = clampValue(roundToDigit(current + delta, digit), min, max);
+        const nextStr = next.toString();
+        internalValueRef.current = nextStr;
+        setInternalValue(nextStr);
+        onValueChange?.(next);
+      },
+      [digit, min, max, onValueChange]
+    );
+    const handleKeyDown = React__namespace.useCallback(
+      (e) => {
+        if (e.key === "Enter") commitValue(internalValue);
+        if (e.key === "ArrowUp") {
+          e.preventDefault();
+          adjust(step);
+        }
+        if (e.key === "ArrowDown") {
+          e.preventDefault();
+          adjust(-step);
+        }
+      },
+      [internalValue, commitValue, step, adjust]
+    );
+    const stopRepeat = React__namespace.useCallback(() => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+      pressCountRef.current = 0;
+    }, []);
+    const startRepeat = React__namespace.useCallback(
+      (delta, e) => {
+        e.preventDefault();
+        adjust(delta);
+        pressCountRef.current = 0;
+        timeoutRef.current = setTimeout(() => {
+          const accelerate = () => {
+            adjust(delta);
+            pressCountRef.current += 1;
+            let delay = 100;
+            if (pressCountRef.current > 20) delay = 30;
+            else if (pressCountRef.current > 10) delay = 50;
+            else if (pressCountRef.current > 5) delay = 75;
+            timeoutRef.current = setTimeout(accelerate, delay);
+          };
+          accelerate();
+        }, 400);
+      },
+      [adjust]
+    );
+    React__namespace.useEffect(() => () => stopRepeat(), [stopRepeat]);
+    const startRepeatRef = React__namespace.useRef(startRepeat);
+    startRepeatRef.current = startRepeat;
+    const stopRepeatRef = React__namespace.useRef(stopRepeat);
+    stopRepeatRef.current = stopRepeat;
+    const adjustRef = React__namespace.useRef(adjust);
+    adjustRef.current = adjust;
+    React__namespace.useImperativeHandle(
+      ref,
+      () => ({
+        get input() {
+          return inputRef.current;
+        },
+        increment: () => adjustRef.current(step),
+        decrement: () => adjustRef.current(-step),
+        startIncrement: (e) => startRepeatRef.current(step, e),
+        startDecrement: (e) => startRepeatRef.current(-step, e),
+        stop: () => stopRepeatRef.current()
+      }),
+      [step]
+    );
+    const padSize = size === "sm" ? "nexus-number-input__field--sm" : size === "xl" ? "nexus-number-input__field--xl" : size === "lg" ? "nexus-number-input__field--lg" : "nexus-number-input__field--md";
+    const showButtons = !hideButtons && !readOnly && !disabled;
+    const numValue = parseFloat(internalValue) || 0;
+    const isMinDisabled = min !== void 0 && numValue <= min;
+    const isMaxDisabled = max !== void 0 && numValue >= max;
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: chunkCZC76ZD5_js.cn(
+          numberInputVariants({ size, state }),
+          disabled && "nexus-number-input--disabled",
+          className
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              ref: inputRef,
+              type: "text",
+              inputMode: "decimal",
+              role: "spinbutton",
+              className: chunkCZC76ZD5_js.cn("nexus-number-input__field", padSize),
+              value: internalValue,
+              disabled,
+              readOnly,
+              placeholder,
+              "aria-invalid": error || void 0,
+              "aria-valuemin": min,
+              "aria-valuemax": max,
+              "aria-valuenow": internalValue ? parseFloat(internalValue) || void 0 : void 0,
+              onChange: handleInputChange,
+              onBlur: handleBlur,
+              onKeyDown: handleKeyDown,
+              ...props
+            }
+          ),
+          showButtons && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "nexus-number-input__buttons", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                tabIndex: -1,
+                disabled: isMaxDisabled,
+                className: "nexus-number-input__step nexus-number-input__step--up",
+                onPointerDown: (e) => startRepeat(step, e),
+                onPointerUp: stopRepeat,
+                onPointerLeave: stopRepeat,
+                "aria-label": "Increase",
+                children: /* @__PURE__ */ jsxRuntime.jsx(ChevronUp, {})
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                tabIndex: -1,
+                disabled: isMinDisabled,
+                className: "nexus-number-input__step nexus-number-input__step--down",
+                onPointerDown: (e) => startRepeat(-step, e),
+                onPointerUp: stopRepeat,
+                onPointerLeave: stopRepeat,
+                "aria-label": "Decrease",
+                children: /* @__PURE__ */ jsxRuntime.jsx(ChevronDown, {})
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+);
+NumberInput.displayName = "NumberInput";
+
+exports.NumberInput = NumberInput;
+exports.numberInputBind = numberInputBind;
+exports.numberInputVariants = numberInputVariants;

package/dist/chunks/chunk-AOXXE5UQ.mjs

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+// src/components/ClientOnly.tsx
+function ClientOnly({ children, fallback = null }) {
+  const [mounted, setMounted] = React.useState(false);
+  React.useEffect(() => {
+    setMounted(true);
+  }, []);
+  return mounted ? /* @__PURE__ */ jsx(Fragment, { children }) : /* @__PURE__ */ jsx(Fragment, { children: fallback });
+}
+ClientOnly.displayName = "ClientOnly";
+
+export { ClientOnly };

package/dist/chunks/chunk-AZ2URLDD.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useInView.ts
+function useInView(options) {
+  const { triggerOnce = true, rootMargin = "200px", threshold = 0 } = options ?? {};
+  const [isInView, setIsInView] = react.useState(false);
+  const observerRef = react.useRef(null);
+  const ref = react.useCallback(
+    (node) => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+        observerRef.current = null;
+      }
+      if (!node) return;
+      if (triggerOnce && isInView) return;
+      const observer = new IntersectionObserver(
+        ([entry]) => {
+          if (entry.isIntersecting) {
+            setIsInView(true);
+            if (triggerOnce) observer.disconnect();
+          } else if (!triggerOnce) {
+            setIsInView(false);
+          }
+        },
+        { rootMargin, threshold }
+      );
+      observer.observe(node);
+      observerRef.current = observer;
+    },
+    [triggerOnce, rootMargin, threshold, isInView]
+  );
+  return { ref, isInView };
+}
+var useInView_default = useInView;
+
+exports.useInView = useInView;
+exports.useInView_default = useInView_default;

package/dist/chunks/chunk-B6G5TJRO.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var ChevronDown = ({ className }) => /* @__PURE__ */ jsxRuntime.jsx("svg", { className, viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4 6l4 4 4-4", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) });
+var Ellipsis = ({
+  className,
+  content = "",
+  triggerMore = "more",
+  triggerLess = "less",
+  lineClamp = 2,
+  defaultShortened = true,
+  observingEnvs = [],
+  onShowMoreLessClick
+}) => {
+  const contentRef = react.useRef(null);
+  const isMeasuringRef = react.useRef(false);
+  const prevObservingEnvs = react.useRef([...observingEnvs]);
+  const [shortened, setShortened] = react.useState(defaultShortened);
+  const [triggerVisible, setTriggerVisible] = react.useState(false);
+  const allocateContentElementStyle = react.useCallback(
+    (style) => {
+      const el = contentRef.current;
+      if (!el) return;
+      if (style) {
+        el.style.maxHeight = `${style.openHeight}px`;
+        el.style.minHeight = `${style.closeHeight}px`;
+        el.style.height = `${style.closeHeight}px`;
+      } else {
+        el.style.maxHeight = "";
+        el.style.minHeight = "";
+        el.style.height = "";
+      }
+    },
+    []
+  );
+  const resetContentElementAfterMeasuring = react.useCallback(
+    ({ openHeight, closeHeight }) => {
+      allocateContentElementStyle({ openHeight, closeHeight });
+      setTriggerVisible(closeHeight + 10 < openHeight);
+      setShortened(defaultShortened);
+      isMeasuringRef.current = false;
+    },
+    [defaultShortened, allocateContentElementStyle]
+  );
+  const initializeContentElement = react.useCallback(() => {
+    allocateContentElementStyle(null);
+    setShortened(true);
+    isMeasuringRef.current = true;
+  }, [allocateContentElementStyle]);
+  const handleToggle = react.useCallback((e) => {
+    e.stopPropagation();
+    setShortened((prev) => !prev);
+  }, []);
+  const contentStyle = react.useMemo(
+    () => shortened ? {
+      display: "-webkit-box",
+      WebkitLineClamp: lineClamp,
+      WebkitBoxOrient: "vertical",
+      overflow: "hidden",
+      height: contentRef.current?.style.minHeight
+    } : {
+      WebkitLineClamp: void 0,
+      height: contentRef.current?.style.maxHeight
+    },
+    [shortened, lineClamp]
+  );
+  react.useLayoutEffect(() => {
+    if (contentRef.current) initializeContentElement();
+  }, [initializeContentElement]);
+  react.useLayoutEffect(() => {
+    if (!contentRef.current) return;
+    const isEnvChanged = observingEnvs.length ? observingEnvs.some((env, i) => env !== prevObservingEnvs.current[i]) : false;
+    if (isEnvChanged) {
+      prevObservingEnvs.current = [...observingEnvs];
+      initializeContentElement();
+    }
+  }, [observingEnvs, initializeContentElement]);
+  react.useLayoutEffect(() => {
+    const el = contentRef.current;
+    if (shortened && isMeasuringRef.current && el) {
+      resetContentElementAfterMeasuring({
+        openHeight: el.scrollHeight,
+        closeHeight: el.offsetHeight
+      });
+    }
+  }, [shortened, content, observingEnvs, resetContentElementAfterMeasuring]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkCZC76ZD5_js.cn("nexus-ellipsis", className), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: contentRef,
+        className: "nexus-ellipsis__content",
+        style: contentStyle,
+        children: typeof content === "string" ? /* @__PURE__ */ jsxRuntime.jsx("span", { dangerouslySetInnerHTML: { __html: content } }) : content
+      }
+    ),
+    triggerVisible && /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: onShowMoreLessClick ?? handleToggle,
+        className: chunkCZC76ZD5_js.cn("nexus-ellipsis__trigger", !shortened && "nexus-ellipsis__trigger--expanded"),
+        "aria-expanded": !shortened,
+        children: [
+          shortened ? triggerMore : triggerLess,
+          /* @__PURE__ */ jsxRuntime.jsx(ChevronDown, { className: "nexus-ellipsis__chevron" })
+        ]
+      }
+    )
+  ] });
+};
+
+exports.Ellipsis = Ellipsis;

package/dist/chunks/chunk-BLGQHR3M.js

@@ -0,0 +1,56 @@
+'use strict';
+
+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);
+
+var Skeleton = React__namespace.forwardRef(
+  ({
+    className,
+    children,
+    as: Tag = "div",
+    circle = false,
+    width,
+    height,
+    style,
+    ...props
+  }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+    Tag,
+    {
+      ref,
+      role: "status",
+      "aria-label": "Loading",
+      className: chunkCZC76ZD5_js.cn(
+        "nexus-skeleton",
+        circle ? "nexus-skeleton--circle" : "nexus-skeleton--rect",
+        className
+      ),
+      style: { width, height, ...style },
+      ...props,
+      children: children && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "nexus-skeleton__children", children })
+    }
+  )
+);
+Skeleton.displayName = "Skeleton";
+
+exports.Skeleton = Skeleton;

package/dist/chunks/chunk-BPUQ2CO2.mjs

@@ -0,0 +1,48 @@
+import { cn } from './chunk-MCKOWMLS.mjs';
+import * as React from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var Spinner = React.forwardRef(
+  ({ className, size = 20, "aria-label": ariaLabel = "Loading", ...props }, ref) => /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      ref,
+      role: "status",
+      "aria-label": ariaLabel,
+      className: cn("nexus-spinner", className),
+      viewBox: "0 0 50 50",
+      fill: "none",
+      style: { width: size, height: size },
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: "25",
+            cy: "25",
+            r: "20",
+            stroke: "currentColor",
+            strokeWidth: "5",
+            opacity: "0.3"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: "25",
+            cy: "25",
+            r: "20",
+            stroke: "currentColor",
+            strokeWidth: "5",
+            strokeLinecap: "round",
+            strokeDasharray: "90 150",
+            strokeDashoffset: "-35"
+          }
+        )
+      ]
+    }
+  )
+);
+Spinner.displayName = "Spinner";
+
+export { Spinner };

package/dist/chunks/chunk-BSZ2LN6E.js

@@ -0,0 +1,129 @@
+'use strict';
+
+var chunkCZC76ZD5_js = require('./chunk-CZC76ZD5.js');
+var React = require('react');
+var vaul = require('vaul');
+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 DrawerDirectionCtx = React__namespace.createContext("bottom");
+var drawerOverlayVariants = classVarianceAuthority.cva("nexus-drawer-overlay", {
+  variants: {
+    blur: {
+      none: "",
+      sm: "nexus-drawer-overlay--blur-sm",
+      md: "nexus-drawer-overlay--blur-md"
+    }
+  },
+  defaultVariants: { blur: "none" }
+});
+var drawerContentVariants = classVarianceAuthority.cva("nexus-drawer-content", {
+  variants: {
+    direction: {
+      bottom: "nexus-drawer-content--bottom",
+      top: "nexus-drawer-content--top",
+      left: "nexus-drawer-content--left",
+      right: "nexus-drawer-content--right"
+    }
+  },
+  defaultVariants: { direction: "bottom" }
+});
+var DrawerRoot = ({ direction = "bottom", ...props }) => /* @__PURE__ */ jsxRuntime.jsx(DrawerDirectionCtx.Provider, { value: direction, children: /* @__PURE__ */ jsxRuntime.jsx(vaul.Drawer.Root, { shouldScaleBackground: false, direction, ...props }) });
+var DrawerTrigger = (props) => /* @__PURE__ */ jsxRuntime.jsx(vaul.Drawer.Trigger, { ...props });
+DrawerTrigger.displayName = "DrawerTrigger";
+var DrawerContent = React__namespace.forwardRef(
+  ({
+    className,
+    children,
+    direction: directionProp,
+    showHandle = true,
+    blur,
+    overlayClassName,
+    ...props
+  }, ref) => {
+    const ctxDirection = React__namespace.useContext(DrawerDirectionCtx);
+    const direction = directionProp ?? ctxDirection;
+    return /* @__PURE__ */ jsxRuntime.jsxs(vaul.Drawer.Portal, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        vaul.Drawer.Overlay,
+        {
+          className: chunkCZC76ZD5_js.cn(drawerOverlayVariants({ blur }), overlayClassName)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        vaul.Drawer.Content,
+        {
+          ref,
+          className: chunkCZC76ZD5_js.cn(drawerContentVariants({ direction }), className),
+          ...props,
+          children: [
+            showHandle && (direction === "bottom" || direction === "top") && /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: chunkCZC76ZD5_js.cn("nexus-drawer-handle", direction === "bottom" ? "nexus-drawer-handle--bottom" : "nexus-drawer-handle--top"),
+                children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "nexus-drawer-handle__bar" })
+              }
+            ),
+            children
+          ]
+        }
+      )
+    ] });
+  }
+);
+DrawerContent.displayName = "DrawerContent";
+var DrawerClose = (props) => /* @__PURE__ */ jsxRuntime.jsx(vaul.Drawer.Close, { ...props });
+DrawerClose.displayName = "DrawerClose";
+var DrawerTitle = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+  vaul.Drawer.Title,
+  {
+    className: chunkCZC76ZD5_js.cn("nexus-drawer-title", className),
+    ...props
+  }
+);
+DrawerTitle.displayName = "DrawerTitle";
+var DrawerDescription = ({ className, ...props }) => /* @__PURE__ */ jsxRuntime.jsx(
+  vaul.Drawer.Description,
+  {
+    className: chunkCZC76ZD5_js.cn("nexus-drawer-description", className),
+    ...props
+  }
+);
+DrawerDescription.displayName = "DrawerDescription";
+var Drawer = Object.assign(DrawerRoot, {
+  Trigger: DrawerTrigger,
+  Content: DrawerContent,
+  Close: DrawerClose,
+  Title: DrawerTitle,
+  Description: DrawerDescription
+});
+
+exports.Drawer = Drawer;
+exports.DrawerClose = DrawerClose;
+exports.DrawerContent = DrawerContent;
+exports.DrawerDescription = DrawerDescription;
+exports.DrawerRoot = DrawerRoot;
+exports.DrawerTitle = DrawerTitle;
+exports.DrawerTrigger = DrawerTrigger;
+exports.drawerContentVariants = drawerContentVariants;
+exports.drawerOverlayVariants = drawerOverlayVariants;