@duskmoon-dev/components 0.1.2

package/dist/components/pagination/index.js

@@ -0,0 +1,281 @@
+"use client";
+
+// src/components/pagination/Pagination.tsx
+import {
+  forwardRef,
+  useMemo,
+  useState
+} from "react";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/pagination.ts
+var paginationBaseClass = "pagination";
+var paginationItemClass = "pagination-item";
+var paginationItemActiveClass = "pagination-item-active";
+var paginationItemDisabledClass = "pagination-item-disabled";
+var paginationPrevClass = "pagination-prev";
+var paginationNextClass = "pagination-next";
+var paginationEllipsisClass = "pagination-ellipsis";
+var paginationCompactClass = "pagination-compact";
+var paginationInfoClass = "pagination-info";
+var paginationInfoTextClass = "pagination-info-text";
+var paginationInputClass = "pagination-input";
+var paginationResponsiveClass = "pagination-responsive";
+var paginationSizeClasses = {
+  sm: "pagination-sm",
+  md: "",
+  lg: "pagination-lg"
+};
+function getPaginationClasses({
+  size = "md",
+  compact,
+  className
+}) {
+  return cn(paginationBaseClass, paginationResponsiveClass, paginationSizeClasses[size], compact && paginationCompactClass, className);
+}
+function getPaginationItemClasses({
+  active,
+  disabled
+}) {
+  return cn(paginationItemClass, active && paginationItemActiveClass, disabled && paginationItemDisabledClass);
+}
+
+// src/components/pagination/Pagination.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var defaultPageSizeOptions = [10, 20, 50, 100];
+function toPositiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value === undefined) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function clampPage(page, pageCount) {
+  return Math.min(pageCount, Math.max(1, Math.floor(page)));
+}
+function getPageCount(total, pageSize) {
+  return Math.max(1, Math.ceil(Math.max(0, total) / pageSize));
+}
+function getRange(current, pageSize, total) {
+  if (total <= 0) {
+    return [0, 0];
+  }
+  const start = (current - 1) * pageSize + 1;
+  const end = Math.min(total, current * pageSize);
+  return [start, end];
+}
+function getPageTokens(current, pageCount) {
+  if (pageCount <= 7) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const pages = new Set([1, pageCount, current - 1, current, current + 1]);
+  if (current <= 4) {
+    [2, 3, 4, 5].forEach((page) => pages.add(page));
+  }
+  if (current >= pageCount - 3) {
+    [pageCount - 4, pageCount - 3, pageCount - 2, pageCount - 1].forEach((page) => pages.add(page));
+  }
+  const sortedPages = Array.from(pages).filter((page) => page >= 1 && page <= pageCount).sort((first, second) => first - second);
+  return sortedPages.reduce((tokens, page) => {
+    const previous = tokens[tokens.length - 1];
+    if (typeof previous === "number") {
+      const gap = page - previous;
+      if (gap === 2) {
+        tokens.push(previous + 1);
+      } else if (gap > 2) {
+        tokens.push("ellipsis");
+      }
+    }
+    tokens.push(page);
+    return tokens;
+  }, []);
+}
+function getSizeOptions(pageSize) {
+  return Array.from(new Set([...defaultPageSizeOptions, pageSize])).sort((first, second) => first - second);
+}
+var Pagination = forwardRef(({
+  current,
+  defaultCurrent = 1,
+  pageSize,
+  defaultPageSize = 10,
+  total = 0,
+  onChange,
+  disabled,
+  simple,
+  showSizeChanger,
+  showQuickJumper,
+  showTotal,
+  size = "md",
+  className,
+  ...props
+}, ref) => {
+  const isCurrentControlled = current !== undefined;
+  const isPageSizeControlled = pageSize !== undefined;
+  const [internalCurrent, setInternalCurrent] = useState(defaultCurrent);
+  const [internalPageSize, setInternalPageSize] = useState(defaultPageSize);
+  const [quickJumpValue, setQuickJumpValue] = useState("");
+  const mergedPageSize = toPositiveInteger(pageSize ?? internalPageSize, defaultPageSize);
+  const pageCount = getPageCount(total, mergedPageSize);
+  const mergedCurrent = clampPage(toPositiveInteger(current ?? internalCurrent, defaultCurrent), pageCount);
+  const pageTokens = useMemo(() => getPageTokens(mergedCurrent, pageCount), [mergedCurrent, pageCount]);
+  const range = getRange(mergedCurrent, mergedPageSize, total);
+  function changePage(nextPage, nextPageSize = mergedPageSize) {
+    const nextPageCount = getPageCount(total, nextPageSize);
+    const normalizedPage = clampPage(nextPage, nextPageCount);
+    if (!isCurrentControlled) {
+      setInternalCurrent(normalizedPage);
+    }
+    if (!isPageSizeControlled) {
+      setInternalPageSize(nextPageSize);
+    }
+    onChange?.(normalizedPage, nextPageSize);
+  }
+  function handlePageSizeChange(event) {
+    const nextPageSize = toPositiveInteger(Number(event.currentTarget.value), mergedPageSize);
+    const nextPage = clampPage(mergedCurrent, getPageCount(total, nextPageSize));
+    changePage(nextPage, nextPageSize);
+  }
+  function jumpToInputPage(value) {
+    const nextPage = Number(value);
+    if (!Number.isFinite(nextPage)) {
+      return;
+    }
+    changePage(nextPage);
+    setQuickJumpValue("");
+  }
+  function handleQuickJumpKeyDown(event) {
+    if (event.key !== "Enter") {
+      return;
+    }
+    jumpToInputPage(event.currentTarget.value);
+  }
+  const previousDisabled = disabled || mergedCurrent <= 1;
+  const nextDisabled = disabled || mergedCurrent >= pageCount;
+  return /* @__PURE__ */ jsxs("nav", {
+    ...props,
+    ref,
+    className: getPaginationClasses({ size, compact: simple, className }),
+    children: [
+      showTotal ? /* @__PURE__ */ jsx("div", {
+        className: paginationInfoClass,
+        children: /* @__PURE__ */ jsx("span", {
+          className: paginationInfoTextClass,
+          children: showTotal(total, range)
+        })
+      }) : null,
+      /* @__PURE__ */ jsx("button", {
+        type: "button",
+        className: paginationPrevClass,
+        disabled: previousDisabled,
+        "aria-label": "Previous page",
+        onClick: () => changePage(mergedCurrent - 1),
+        children: "Prev"
+      }),
+      simple ? /* @__PURE__ */ jsxs("div", {
+        className: paginationInputClass,
+        children: [
+          /* @__PURE__ */ jsx("input", {
+            "aria-label": "Current page",
+            type: "number",
+            min: 1,
+            max: pageCount,
+            value: quickJumpValue || String(mergedCurrent),
+            disabled,
+            onChange: (event) => setQuickJumpValue(event.currentTarget.value),
+            onKeyDown: handleQuickJumpKeyDown,
+            onBlur: (event) => {
+              if (event.currentTarget.value !== String(mergedCurrent)) {
+                jumpToInputPage(event.currentTarget.value);
+              }
+            }
+          }),
+          /* @__PURE__ */ jsxs("span", {
+            className: paginationInfoTextClass,
+            children: [
+              "/ ",
+              pageCount
+            ]
+          })
+        ]
+      }) : pageTokens.map((pageToken, index) => pageToken === "ellipsis" ? /* @__PURE__ */ jsx("span", {
+        "aria-hidden": "true",
+        className: paginationEllipsisClass
+      }, `ellipsis-${index}`) : /* @__PURE__ */ jsx("button", {
+        type: "button",
+        className: getPaginationItemClasses({
+          active: pageToken === mergedCurrent,
+          disabled
+        }),
+        disabled,
+        "aria-current": pageToken === mergedCurrent ? "page" : undefined,
+        "aria-label": `Page ${pageToken}`,
+        onClick: () => changePage(pageToken),
+        children: pageToken
+      }, pageToken)),
+      /* @__PURE__ */ jsx("button", {
+        type: "button",
+        className: paginationNextClass,
+        disabled: nextDisabled,
+        "aria-label": "Next page",
+        onClick: () => changePage(mergedCurrent + 1),
+        children: "Next"
+      }),
+      showSizeChanger ? /* @__PURE__ */ jsx("div", {
+        className: paginationInputClass,
+        children: /* @__PURE__ */ jsx("select", {
+          "aria-label": "Page size",
+          value: mergedPageSize,
+          disabled,
+          onChange: handlePageSizeChange,
+          children: getSizeOptions(mergedPageSize).map((option) => /* @__PURE__ */ jsxs("option", {
+            value: option,
+            children: [
+              option,
+              " / page"
+            ]
+          }, option))
+        })
+      }) : null,
+      showQuickJumper && !simple ? /* @__PURE__ */ jsx("div", {
+        className: paginationInputClass,
+        children: /* @__PURE__ */ jsx("input", {
+          "aria-label": "Jump to page",
+          type: "number",
+          min: 1,
+          max: pageCount,
+          value: quickJumpValue,
+          disabled,
+          onChange: (event) => setQuickJumpValue(event.currentTarget.value),
+          onKeyDown: handleQuickJumpKeyDown
+        })
+      }) : null
+    ]
+  });
+});
+Pagination.displayName = "Pagination";
+export {
+  Pagination
+};

package/dist/components/popconfirm/Popconfirm.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { PopconfirmProps } from "./Popconfirm.types";
+export declare const Popconfirm: React.ForwardRefExoticComponent<Omit<PopconfirmProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/components/popconfirm/Popconfirm.types.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentProps, MouseEvent, ReactElement, ReactNode } from "react";
+import type { ButtonProps } from "../button/Button.types";
+export type PopconfirmPlacement = "top" | "bottom" | "left" | "right" | "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "leftTop" | "leftBottom" | "rightTop" | "rightBottom";
+export type PopconfirmTrigger = "hover" | "focus" | "click" | "contextMenu" | "contextmenu";
+export type PopconfirmAction = void | Promise<void> | Promise<unknown> | unknown;
+export interface PopconfirmProps extends Omit<ComponentProps<"span">, "children" | "title"> {
+    title?: ReactNode;
+    description?: ReactNode;
+    placement?: PopconfirmPlacement;
+    trigger?: PopconfirmTrigger | PopconfirmTrigger[];
+    icon?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    arrow?: boolean;
+    destroyTooltipOnHide?: boolean;
+    okText?: ReactNode;
+    cancelText?: ReactNode;
+    okButtonProps?: ButtonProps;
+    cancelButtonProps?: ButtonProps;
+    showCancel?: boolean;
+    onConfirm?: (event: MouseEvent<HTMLButtonElement>) => PopconfirmAction;
+    onCancel?: (event: MouseEvent<HTMLButtonElement>) => PopconfirmAction;
+    onOpenChange?: (open: boolean) => void;
+    children: ReactElement;
+}

package/dist/components/popconfirm/index.d.ts

@@ -0,0 +1,2 @@
+export { Popconfirm } from "./Popconfirm";
+export type { PopconfirmAction, PopconfirmPlacement, PopconfirmProps, PopconfirmTrigger, } from "./Popconfirm.types";

package/dist/components/popconfirm/index.js

@@ -0,0 +1,364 @@
+"use client";
+
+// ../../node_modules/.bun/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if (typeof e == "string" || typeof e == "number")
+    n += e;
+  else if (typeof e == "object")
+    if (Array.isArray(e)) {
+      var o = e.length;
+      for (t = 0;t < o; t++)
+        e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+    } else
+      for (f in e)
+        e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length;f < o; f++)
+    (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+
+// src/utils/cn.ts
+function cn(...inputs) {
+  return clsx(inputs);
+}
+// src/classes/button.ts
+var buttonBaseClass = "btn";
+var buttonColorClasses = {
+  primary: "btn-primary",
+  secondary: "btn-secondary",
+  tertiary: "btn-tertiary",
+  info: "btn-info",
+  success: "btn-success",
+  warning: "btn-warning",
+  error: "btn-error"
+};
+var buttonAppearanceClasses = {
+  filled: "",
+  outline: "btn-outline",
+  tonal: "btn-tonal",
+  ghost: "btn-ghost",
+  text: "btn-text"
+};
+var buttonShapeClasses = {
+  rect: "",
+  circle: "btn-circle",
+  square: "btn-square"
+};
+var buttonSizeClasses = {
+  xs: "btn-xs",
+  sm: "btn-sm",
+  md: "btn-md",
+  lg: "btn-lg"
+};
+var buttonBlockClass = "btn-block";
+var buttonIsLoadingClass = "btn-loading";
+function getButtonClasses({
+  color = "primary",
+  appearance = "filled",
+  shape = "rect",
+  size = "md",
+  block,
+  isLoading,
+  className
+}) {
+  return cn(buttonBaseClass, buttonColorClasses[color], buttonAppearanceClasses[appearance], buttonShapeClasses[shape], buttonSizeClasses[size], block && buttonBlockClass, isLoading && buttonIsLoadingClass, className);
+}
+
+// src/components/button/Button.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function Button({
+  color = "primary",
+  appearance = "filled",
+  shape = "rect",
+  size = "md",
+  block,
+  isLoading,
+  leftIcon,
+  rightIcon,
+  className,
+  children,
+  disabled,
+  ref,
+  ...props
+}) {
+  const classes = getButtonClasses({
+    color,
+    appearance,
+    shape,
+    size,
+    block,
+    isLoading,
+    className
+  });
+  return /* @__PURE__ */ jsxs("button", {
+    ref,
+    className: classes,
+    disabled: disabled || isLoading,
+    "aria-busy": isLoading,
+    "aria-disabled": disabled || isLoading,
+    ...props,
+    children: [
+      isLoading && /* @__PURE__ */ jsx("span", {
+        className: "btn-spinner"
+      }),
+      !isLoading && leftIcon && /* @__PURE__ */ jsx("span", {
+        className: "btn-icon-left",
+        children: leftIcon
+      }),
+      /* @__PURE__ */ jsx("span", {
+        className: "btn-content",
+        children
+      }),
+      !isLoading && rightIcon && /* @__PURE__ */ jsx("span", {
+        className: "btn-icon-right",
+        children: rightIcon
+      })
+    ]
+  });
+}
+// src/components/popconfirm/Popconfirm.tsx
+import {
+  forwardRef,
+  useId,
+  useState
+} from "react";
+
+// src/classes/popconfirm.ts
+var popconfirmWrapperClass = "popover-wrapper popconfirm-wrapper";
+var popconfirmBaseClass = "popover popconfirm";
+var popconfirmOpenClass = "popover-show popconfirm-open";
+var popconfirmArrowClass = "popover-arrow popconfirm-arrow";
+var popconfirmNoArrowClass = "popover-no-arrow popconfirm-no-arrow";
+var popconfirmBodyClass = "popconfirm-body";
+var popconfirmIconClass = "popconfirm-icon";
+var popconfirmContentClass = "popconfirm-content";
+var popconfirmTitleClass = "popconfirm-title";
+var popconfirmDescriptionClass = "popconfirm-description";
+var popconfirmActionsClass = "popconfirm-actions";
+var popconfirmPlacementClasses = {
+  top: "popover-top popconfirm-top",
+  bottom: "popover-bottom popconfirm-bottom",
+  left: "popover-left popconfirm-left",
+  right: "popover-right popconfirm-right",
+  topLeft: "popover-top popconfirm-top-left",
+  topRight: "popover-top popconfirm-top-right",
+  bottomLeft: "popover-bottom popconfirm-bottom-left",
+  bottomRight: "popover-bottom popconfirm-bottom-right",
+  leftTop: "popover-left popconfirm-left-top",
+  leftBottom: "popover-left popconfirm-left-bottom",
+  rightTop: "popover-right popconfirm-right-top",
+  rightBottom: "popover-right popconfirm-right-bottom"
+};
+function getPopconfirmClasses({
+  placement = "top",
+  open,
+  arrow = true,
+  className
+}) {
+  return cn(popconfirmBaseClass, popconfirmPlacementClasses[placement], open && popconfirmOpenClass, !arrow && popconfirmNoArrowClass, className);
+}
+
+// src/components/popconfirm/Popconfirm.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function normalizeTriggers(trigger) {
+  return Array.isArray(trigger) ? trigger : [trigger ?? "click"];
+}
+function hasTrigger(triggers, trigger) {
+  return normalizeTriggers(triggers).includes(trigger);
+}
+function isPromiseLike(value) {
+  return Boolean(value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function");
+}
+var Popconfirm = forwardRef(({
+  arrow = true,
+  cancelButtonProps,
+  cancelText = "Cancel",
+  children,
+  className,
+  defaultOpen,
+  description,
+  destroyTooltipOnHide,
+  disabled,
+  icon = "!",
+  id,
+  okButtonProps,
+  okText = "OK",
+  onCancel,
+  onClick,
+  onConfirm,
+  onContextMenu,
+  onFocus,
+  onBlur,
+  onMouseEnter,
+  onMouseLeave,
+  onOpenChange,
+  open,
+  placement = "top",
+  showCancel = true,
+  title,
+  trigger = "click",
+  ...props
+}, ref) => {
+  const [internalOpen, setInternalOpen] = useState(Boolean(defaultOpen));
+  const [confirmLoading, setConfirmLoading] = useState(false);
+  const generatedPopupId = useId();
+  const isControlled = open !== undefined;
+  const visible = isControlled ? open : internalOpen;
+  const popupId = id ? `${id}-popconfirm` : generatedPopupId;
+  function setVisible(nextOpen) {
+    if (disabled) {
+      return;
+    }
+    if (!isControlled) {
+      setInternalOpen(nextOpen);
+    }
+    onOpenChange?.(nextOpen);
+  }
+  function close() {
+    setVisible(false);
+  }
+  async function runAction(action, event, loading) {
+    event.preventDefault();
+    event.stopPropagation();
+    const result = action?.(event);
+    if (!isPromiseLike(result)) {
+      close();
+      return;
+    }
+    if (loading) {
+      setConfirmLoading(true);
+    }
+    try {
+      await result;
+      close();
+    } finally {
+      if (loading) {
+        setConfirmLoading(false);
+      }
+    }
+  }
+  function handleMouseEnter(event) {
+    onMouseEnter?.(event);
+    if (hasTrigger(trigger, "hover")) {
+      setVisible(true);
+    }
+  }
+  function handleMouseLeave(event) {
+    onMouseLeave?.(event);
+    if (hasTrigger(trigger, "hover")) {
+      setVisible(false);
+    }
+  }
+  function handleClick(event) {
+    onClick?.(event);
+    if (hasTrigger(trigger, "click")) {
+      setVisible(!visible);
+    }
+  }
+  function handleContextMenu(event) {
+    onContextMenu?.(event);
+    if (hasTrigger(trigger, "contextMenu") || hasTrigger(trigger, "contextmenu")) {
+      event.preventDefault();
+      setVisible(!visible);
+    }
+  }
+  function handleFocus(event) {
+    onFocus?.(event);
+    if (hasTrigger(trigger, "focus")) {
+      setVisible(true);
+    }
+  }
+  function handleBlur(event) {
+    onBlur?.(event);
+    if (hasTrigger(trigger, "focus")) {
+      setVisible(false);
+    }
+  }
+  const shouldRenderPopup = !destroyTooltipOnHide || visible;
+  return /* @__PURE__ */ jsxs2("span", {
+    ...props,
+    ref,
+    className: popconfirmWrapperClass,
+    "aria-describedby": visible ? popupId : undefined,
+    "aria-expanded": visible || undefined,
+    onMouseEnter: handleMouseEnter,
+    onMouseLeave: handleMouseLeave,
+    onClick: handleClick,
+    onContextMenu: handleContextMenu,
+    onFocus: handleFocus,
+    onBlur: handleBlur,
+    children: [
+      children,
+      shouldRenderPopup ? /* @__PURE__ */ jsxs2("span", {
+        id: popupId,
+        role: "tooltip",
+        className: getPopconfirmClasses({
+          placement,
+          open: visible,
+          arrow,
+          className
+        }),
+        children: [
+          /* @__PURE__ */ jsxs2("span", {
+            className: popconfirmBodyClass,
+            children: [
+              icon ? /* @__PURE__ */ jsx2("span", {
+                className: popconfirmIconClass,
+                children: icon
+              }) : null,
+              /* @__PURE__ */ jsxs2("span", {
+                className: popconfirmContentClass,
+                children: [
+                  title ? /* @__PURE__ */ jsx2("span", {
+                    className: popconfirmTitleClass,
+                    children: title
+                  }) : null,
+                  description ? /* @__PURE__ */ jsx2("span", {
+                    className: popconfirmDescriptionClass,
+                    children: description
+                  }) : null
+                ]
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsxs2("span", {
+            className: popconfirmActionsClass,
+            children: [
+              showCancel ? /* @__PURE__ */ jsx2(Button, {
+                appearance: "text",
+                color: "secondary",
+                size: "sm",
+                ...cancelButtonProps,
+                onClick: (event) => {
+                  runAction(onCancel, event);
+                },
+                children: cancelText
+              }) : null,
+              /* @__PURE__ */ jsx2(Button, {
+                color: "primary",
+                size: "sm",
+                ...okButtonProps,
+                isLoading: confirmLoading || okButtonProps?.isLoading,
+                onClick: (event) => {
+                  runAction(onConfirm, event, true);
+                },
+                children: okText
+              })
+            ]
+          }),
+          arrow ? /* @__PURE__ */ jsx2("span", {
+            className: popconfirmArrowClass
+          }) : null
+        ]
+      }) : null
+    ]
+  });
+});
+Popconfirm.displayName = "Popconfirm";
+export {
+  Popconfirm
+};

package/dist/components/popover/Popover.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { PopoverProps } from "./Popover.types";
+export declare const Popover: React.ForwardRefExoticComponent<Omit<PopoverProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;

package/dist/components/popover/Popover.types.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentProps, ReactNode } from "react";
+export type PopoverPlacement = "top" | "bottom" | "left" | "right";
+export type PopoverTrigger = "hover" | "focus" | "click" | "contextmenu";
+export interface PopoverProps extends Omit<ComponentProps<"span">, "children" | "content" | "title"> {
+    title?: ReactNode;
+    content?: ReactNode;
+    placement?: PopoverPlacement;
+    trigger?: PopoverTrigger;
+    open?: boolean;
+    defaultOpen?: boolean;
+    arrow?: boolean;
+    destroyTooltipOnHide?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: ReactNode;
+}

package/dist/components/popover/index.d.ts

@@ -0,0 +1,2 @@
+export { Popover } from "./Popover";
+export type { PopoverPlacement, PopoverProps, PopoverTrigger } from "./Popover.types";