@dimasbaguspm/versaur 0.0.19 → 0.0.21

package/dist/js/text-CRsIInRA.js

@@ -0,0 +1,127 @@
+import { c as u, j as b, a as y } from "./index-DOdDlCoL.js";
+import { forwardRef as w } from "react";
+const j = u("", {
+  variants: {
+    color: {
+      primary: "text-primary",
+      secondary: "text-secondary",
+      tertiary: "text-tertiary",
+      ghost: "text-ghost",
+      neutral: "text-ghost",
+      success: "text-success",
+      info: "text-info",
+      warning: "text-warning",
+      danger: "text-danger",
+      inherit: "",
+      gray: "text-gray-500",
+      black: "text-black",
+      white: "text-white"
+    },
+    hasUnderline: {
+      true: "underline",
+      false: ""
+    },
+    isCapitalize: {
+      true: "capitalize",
+      false: ""
+    },
+    align: {
+      left: "text-left",
+      center: "text-center",
+      right: "text-right",
+      justify: "text-justify"
+    },
+    italic: {
+      true: "italic",
+      false: ""
+    },
+    clamp: {
+      1: "line-clamp-1",
+      2: "line-clamp-2",
+      3: "line-clamp-3",
+      4: "line-clamp-4",
+      5: "line-clamp-5",
+      none: ""
+    },
+    ellipsis: {
+      true: "truncate",
+      false: ""
+    },
+    as: {
+      h1: "font-bold text-4xl leading-loose",
+      h2: "font-semibold text-3xl leading-relaxed",
+      h3: "font-medium text-2xl leading-relaxed",
+      h4: "font-bold text-xl leading-normal",
+      h5: "font-semibold text-lg leading-normal",
+      h6: "font-medium text-base leading-normal",
+      p: "font-normal text-base leading-normal",
+      span: "font-normal text-base leading-normal",
+      label: "font-normal text-xs leading-normal"
+    }
+  },
+  defaultVariants: {
+    color: "neutral",
+    hasUnderline: !1,
+    isCapitalize: !1,
+    align: "left",
+    italic: !1,
+    clamp: "none",
+    ellipsis: !1,
+    as: "span"
+  }
+}), v = w(
+  ({
+    as: e = "span",
+    color: l = "ghost",
+    hasUnderline: n = !1,
+    isCapitalize: s = !1,
+    align: i = "left",
+    italic: r = !1,
+    clamp: o = "none",
+    ellipsis: x = !1,
+    fontSize: t,
+    fontWeight: a,
+    className: c,
+    children: f,
+    ...d
+  }, m) => {
+    const g = [
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "p",
+      "span",
+      "label"
+    ].includes(e) ? e : "span", h = t ? `text-${t}` : "", p = a ? `font-${a}` : "";
+    return /* @__PURE__ */ b.jsx(
+      e,
+      {
+        ref: m,
+        className: y(
+          j({
+            color: l,
+            hasUnderline: n,
+            isCapitalize: s,
+            align: i,
+            italic: r,
+            clamp: o,
+            ellipsis: x,
+            // @ts-expect-error - `as` is not a valid variant
+            as: g
+          }),
+          h,
+          p,
+          c
+        ),
+        ...d,
+        children: f
+      }
+    );
+  }
+);
+export {
+  v as T
+};

package/dist/js/tooltip-CDdl1U3A.js

@@ -0,0 +1,148 @@
+import { c as h, j as u, a as b } from "./index-DOdDlCoL.js";
+import { useEffect as m, useRef as c, useId as v, cloneElement as x, useState as g } from "react";
+import { T as j } from "./text-CRsIInRA.js";
+const I = h(
+  "absolute z-30 min-w-40 bg-background rounded-lg border border-border transition-all duration-200 ease-out will-change-transform",
+  {
+    variants: {
+      size: {
+        sm: "py-1.5 px-1",
+        md: "py-2 px-1"
+      },
+      open: {
+        true: "opacity-100 translate-y-1",
+        false: "opacity-0 pointer-events-none translate-y-3"
+      }
+    },
+    defaultVariants: {
+      size: "md",
+      open: !1
+    }
+  }
+);
+function E(t, e, r, o) {
+  m(() => {
+    if (!t) return;
+    function n(s) {
+      !e.current?.contains(s.target) && !r.current?.contains(s.target) && o();
+    }
+    return document.addEventListener("mousedown", n), () => document.removeEventListener("mousedown", n);
+  }, [t, o, e, r]);
+}
+function M(t, e) {
+  m(() => {
+    if (t && e.current) {
+      const r = e.current.querySelectorAll('[role="menuitem"]');
+      r.length && r[0].focus();
+    }
+  }, [t, e]);
+}
+const F = ({
+  isOpen: t,
+  onOutsideClick: e,
+  size: r = "md",
+  content: o,
+  children: n
+}) => {
+  const s = c(null), a = c(null), i = v();
+  return E(t, a, s, e), M(t, a), /* @__PURE__ */ u.jsxs("div", { className: "relative w-fit", children: [
+    x(n, {
+      // @ts-expect-error: ref is valid for button or forwardRef components
+      ref: s,
+      "aria-haspopup": "menu",
+      "aria-expanded": t,
+      "aria-controls": i,
+      tabIndex: 0
+    }),
+    /* @__PURE__ */ u.jsx(
+      "div",
+      {
+        id: i,
+        ref: a,
+        className: b(I({ size: r, open: t })),
+        role: "menu",
+        "aria-hidden": !t,
+        children: o
+      }
+    )
+  ] });
+};
+function z(t = "auto") {
+  const e = c(null), [r, o] = g("bottom");
+  return m(() => {
+    if (!open || t !== "auto" || !e.current) {
+      o(t === "auto" ? "bottom" : t);
+      return;
+    }
+    const n = e.current.getBoundingClientRect(), s = window.innerWidth, a = window.innerHeight, i = {
+      top: n.top,
+      bottom: a - n.bottom,
+      left: n.left,
+      right: s - n.right
+    };
+    i.bottom > 64 ? o("bottom") : i.top > 64 ? o("top") : i.right > 128 ? o("right") : o("left");
+  }, [t, e]), { position: r, ref: e };
+}
+const P = h(
+  "absolute z-50 px-2 py-1 rounded bg-neutral pointer-events-auto transition-opacity duration-150 min-w-[max-content] max-w-sm whitespace-pre-line",
+  {
+    variants: {
+      position: {
+        top: "bottom-full left-1/2 -translate-x-1/2 mb-2",
+        bottom: "top-full left-1/2 -translate-x-1/2 mt-2",
+        left: "right-full top-1/2 -translate-y-1/2 mr-2",
+        right: "left-full top-1/2 -translate-y-1/2 ml-2",
+        auto: "top-full left-1/2 -translate-x-1/2 mt-2"
+      }
+    },
+    defaultVariants: {
+      position: "auto"
+    }
+  }
+), L = ({
+  children: t,
+  content: e,
+  position: r = "auto",
+  popoverClassName: o,
+  delay: n,
+  ...s
+}) => {
+  const a = v(), [i, d] = g(!1), l = c(null), p = () => {
+    n ? l.current = setTimeout(() => d(!0), n) : d(!0);
+  }, f = () => {
+    l.current && clearTimeout(l.current), d(!1);
+  };
+  m(() => () => {
+    l.current && clearTimeout(l.current);
+  }, []);
+  const w = {
+    tabIndex: 0,
+    "aria-describedby": a,
+    onMouseEnter: p,
+    onFocus: p,
+    onMouseLeave: f,
+    onBlur: f,
+    ...s
+  }, { ref: y, position: T } = z(r);
+  return /* @__PURE__ */ u.jsxs("div", { className: "relative w-fit", ref: y, children: [
+    x(t, w),
+    /* @__PURE__ */ u.jsx(
+      "div",
+      {
+        id: a,
+        className: b(
+          P({ position: T }),
+          o,
+          !i && "opacity-0 pointer-events-none"
+        ),
+        role: "tooltip",
+        "aria-hidden": !i,
+        children: /* @__PURE__ */ u.jsx(j, { as: "p", fontSize: "xs", fontWeight: "normal", color: "black", children: e })
+      }
+    )
+  ] });
+};
+export {
+  F as M,
+  L as T
+};

package/dist/types/forms/bottom-sheet-input/bottom-sheet-input.d.ts

@@ -0,0 +1,7 @@
+import { BottomSheetInputProps } from './types';
+export declare const BottomSheetInput: import('react').ForwardRefExoticComponent<BottomSheetInputProps & import('react').RefAttributes<HTMLInputElement>> & {
+    Header: import('react').ForwardRefExoticComponent<import('../..').BottomSheetHeaderProps & import('react').RefAttributes<HTMLDivElement>>;
+    Body: import('react').ForwardRefExoticComponent<import('../..').BottomSheetBodyProps & import('react').RefAttributes<HTMLDivElement>>;
+    Footer: import('react').ForwardRefExoticComponent<import('../..').BottomSheetFooterProps & import('react').RefAttributes<HTMLDivElement>>;
+    Title: import('react').ForwardRefExoticComponent<import('../..').BottomSheetTitleProps & import('react').RefAttributes<HTMLHeadingElement>>;
+};

package/dist/types/forms/bottom-sheet-input/index.d.ts

@@ -0,0 +1,2 @@
+export { BottomSheetInput } from './bottom-sheet-input';
+export type * from './types';

package/dist/types/forms/bottom-sheet-input/types.d.ts

@@ -0,0 +1,17 @@
+import { TextInputProps } from '../text-input/types';
+import { ChangeEventHandler, InputHTMLAttributes, ReactNode } from 'react';
+export interface BottomSheetInputContextValue {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    value: InputHTMLAttributes<HTMLInputElement>['value'];
+}
+/**
+ * BottomSheetInputProps extends TextInputProps, but input is always readOnly
+ * @property {boolean} open - BottomSheet open state (controlled)
+ * @property {(open: boolean) => void} onOpenChange - Callback for sheet open state change
+ * @property {React.ReactNode} children - BottomSheet content
+ */
+export interface BottomSheetInputProps extends Omit<TextInputProps, 'readOnly' | 'children'> {
+    children: (ctx: BottomSheetInputContextValue) => ReactNode;
+}

package/dist/types/forms/drawer-input/drawer-input.d.ts

@@ -0,0 +1,6 @@
+import { DrawerInputProps } from './types';
+export declare const DrawerInput: import('react').ForwardRefExoticComponent<DrawerInputProps & import('react').RefAttributes<HTMLInputElement>> & {
+    Header: import('react').ForwardRefExoticComponent<import('../..').DrawerHeaderProps & import('react').RefAttributes<HTMLDivElement>>;
+    Body: import('react').ForwardRefExoticComponent<import('../..').DrawerBodyProps & import('react').RefAttributes<HTMLDivElement>>;
+    Footer: import('react').ForwardRefExoticComponent<import('../..').DrawerFooterProps & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/types/forms/drawer-input/index.d.ts

@@ -0,0 +1,2 @@
+export { DrawerInput } from './drawer-input';
+export type * from './types';

package/dist/types/forms/drawer-input/types.d.ts

@@ -0,0 +1,18 @@
+import { DrawerProps } from '../../overlays/drawer/types';
+import { TextInputProps } from '../text-input/types';
+import { ChangeEventHandler, InputHTMLAttributes, ReactNode } from 'react';
+export interface DrawerInputContextValue {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    value: InputHTMLAttributes<HTMLInputElement>['value'];
+}
+/**
+ * DrawerInputProps extends TextInputProps, but input is always readOnly
+ * @property {boolean} open - Drawer open state (controlled)
+ * @property {(open: boolean) => void} onOpenChange - Callback for drawer open state change
+ * @property {React.ReactNode} children - Drawer content
+ */
+export interface DrawerInputProps extends Omit<TextInputProps, 'readOnly' | 'children'>, Pick<DrawerProps, 'size' | 'position'> {
+    children: (ctx: DrawerInputContextValue) => ReactNode;
+}

package/dist/types/forms/index.d.ts

@@ -15,3 +15,6 @@ export * from './price-input';
 export * from './email-input';
 export * from './selectable-single-input';
 export * from './selectable-multiple-input';
+export * from './modal-input';
+export * from './drawer-input';
+export * from './bottom-sheet-input';

package/dist/types/forms/modal-input/index.d.ts

@@ -0,0 +1,2 @@
+export { ModalInput } from './modal-input';
+export type * from './types';

package/dist/types/forms/modal-input/modal-input.d.ts

@@ -0,0 +1,6 @@
+import { ModalInputProps } from './types';
+export declare const ModalInput: import('react').ForwardRefExoticComponent<ModalInputProps & import('react').RefAttributes<HTMLInputElement>> & {
+    Header: import('react').ForwardRefExoticComponent<import('../..').ModalHeaderProps & import('react').RefAttributes<HTMLDivElement>>;
+    Body: import('react').ForwardRefExoticComponent<import('../..').ModalBodyProps & import('react').RefAttributes<HTMLDivElement>>;
+    Footer: import('react').ForwardRefExoticComponent<import('../..').ModalFooterProps & import('react').RefAttributes<HTMLDivElement>>;
+};

package/dist/types/forms/modal-input/types.d.ts

@@ -0,0 +1,18 @@
+import { ModalRootProps } from '../../overlays';
+import { TextInputProps } from '../text-input/types';
+import { ChangeEventHandler, InputHTMLAttributes, ReactNode } from 'react';
+export interface ModalInputContextValue {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    value: InputHTMLAttributes<HTMLInputElement>['value'];
+}
+/**
+ * ModalInputProps extends TextInputProps, but input is always readOnly
+ * @property {boolean} open - Modal open state (controlled)
+ * @property {(open: boolean) => void} onOpenChange - Callback for modal open state change
+ * @property {React.ReactNode} children - Modal content
+ */
+export interface ModalInputProps extends Omit<TextInputProps, 'readOnly' | 'children'>, Pick<ModalRootProps, 'size' | 'placement'> {
+    children: (ctx: ModalInputContextValue) => ReactNode;
+}

package/dist/types/layouts/index.d.ts

@@ -3,3 +3,4 @@ export * from './bottom-bar';
 export * from './top-bar';
 export * from './page-layout';
 export * from './form-layout';
+export * from './side-bar';

package/dist/types/layouts/side-bar/index.d.ts

@@ -0,0 +1,2 @@
+export { SideBar } from './side-bar';
+export type * from './types';

package/dist/types/layouts/side-bar/side-bar.atoms.d.ts

@@ -0,0 +1,3 @@
+import { SideBarItemProps, SideBarGroupProps } from './types';
+export declare const SideBarItem: import('react').ForwardRefExoticComponent<SideBarItemProps & import('react').RefAttributes<HTMLElement>>;
+export declare const SideBarGroup: import('react').ForwardRefExoticComponent<SideBarGroupProps & import('react').RefAttributes<HTMLLIElement>>;

package/dist/types/layouts/side-bar/side-bar.d.ts

@@ -0,0 +1,5 @@
+import { SideBarProps } from './types';
+export declare const SideBar: import('react').ForwardRefExoticComponent<SideBarProps & import('react').RefAttributes<HTMLElement>> & {
+    Item: import('react').ForwardRefExoticComponent<import('./types').SideBarItemProps & import('react').RefAttributes<HTMLElement>>;
+    Group: import('react').ForwardRefExoticComponent<import('./types').SideBarGroupProps & import('react').RefAttributes<HTMLLIElement>>;
+};

package/dist/types/layouts/side-bar/types.d.ts

@@ -0,0 +1,42 @@
+import { HTMLAttributes, AnchorHTMLAttributes, ReactNode, ButtonHTMLAttributes } from 'react';
+/**
+ * Props for the SideBar root component
+ */
+export interface SideBarProps extends HTMLAttributes<HTMLElement> {
+    /**
+     * Children nodes (MenuList, etc)
+     */
+    children: ReactNode;
+}
+interface SideBarItemBaseAsAnchor extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    active?: boolean;
+    icon: ReactNode;
+    children: ReactNode;
+    onClick?: never;
+    href: AnchorHTMLAttributes<HTMLAnchorElement>['href'];
+}
+interface SideBarItemBaseAsButton extends ButtonHTMLAttributes<HTMLButtonElement> {
+    active?: boolean;
+    icon?: ReactNode;
+    children: ReactNode;
+    onClick?: ButtonHTMLAttributes<HTMLButtonElement>['onClick'];
+    href?: never;
+}
+/**
+ * Props for the SideBar.Item component (polymorphic: anchor or button)
+ */
+export type SideBarItemProps = SideBarItemBaseAsAnchor | SideBarItemBaseAsButton;
+/**
+ * Props for the SideBar.Group component
+ */
+export interface SideBarGroupProps extends HTMLAttributes<HTMLLIElement> {
+    /**
+     * Label for the group
+     */
+    label: ReactNode;
+    /**
+     * Children (SideBar.Item)
+     */
+    children: ReactNode;
+}
+export {};

package/dist/types/overlays/bottom-sheet/types.d.ts

@@ -1,8 +1,9 @@
+import { OverlayPortalProps } from '../../utils/overlay-portal';
 import { HTMLAttributes } from 'react';
 /**
  * Props for BottomSheetRoot (main component)
  */
-export interface BottomSheetProps extends HTMLAttributes<HTMLDivElement> {
+export interface BottomSheetProps extends HTMLAttributes<HTMLDivElement>, OverlayPortalProps {
     /**
      * Controls open state (controlled only)
      */

package/dist/types/overlays/drawer/types.d.ts

@@ -1,6 +1,7 @@
 import { ComponentPropsWithoutRef, HTMLAttributes, ReactNode } from 'react';
 import { VariantProps } from '../../utils/variants';
 import { drawerVariants } from './helpers';
+import { OverlayPortalProps } from '../../utils/overlay-portal';
 /**
  * Drawer transition type options
  */
@@ -41,7 +42,7 @@ export interface DrawerContextValue {
 /**
  * Props for the Drawer component (controlled component)
  */
-export interface DrawerProps extends ComponentPropsWithoutRef<'div'> {
+export interface DrawerProps extends ComponentPropsWithoutRef<'div'>, OverlayPortalProps {
     /** Whether the drawer is open (required - controlled component) */
     isOpen: boolean;
     /** Callback when the drawer should close */

package/dist/types/overlays/index.d.ts

@@ -2,3 +2,4 @@ export * from './drawer';
 export * from './menu';
 export * from './modal';
 export * from './bottom-sheet';
+export * from './tooltip';

package/dist/types/overlays/menu/menu.atoms.d.ts

@@ -1,14 +1,9 @@
-import { default as React } from 'react';
-import { MenuTriggerProps, MenuContentProps, MenuItemProps } from './types';
+import { MenuContentProps, MenuItemProps } from './types';
 /**
- * MenuTrigger: Button to open/close menu
+ * MenuContent: Wraps menu items
  */
-export declare const MenuTrigger: React.ForwardRefExoticComponent<MenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const MenuContent: import('react').ForwardRefExoticComponent<MenuContentProps & import('react').RefAttributes<HTMLUListElement>>;
 /**
- * MenuContent: Menu popup, positioned below trigger
+ * MenuItem: Single menu item
  */
-export declare const MenuContent: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
-/**
- * MenuItem: Single menu option
- */
-export declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const MenuItem: import('react').ForwardRefExoticComponent<MenuItemProps & import('react').RefAttributes<HTMLLIElement>>;

package/dist/types/overlays/menu/menu.d.ts

@@ -1,7 +1,3 @@
 import { default as React } from 'react';
-import { MenuRootProps } from './types';
-export declare const Menu: React.FC<MenuRootProps> & {
-    Trigger: React.ForwardRefExoticComponent<import('./types').MenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
-    Content: React.ForwardRefExoticComponent<import('./types').MenuContentProps & React.RefAttributes<HTMLDivElement>>;
-    Item: React.ForwardRefExoticComponent<import('./types').MenuItemProps & React.RefAttributes<HTMLButtonElement>>;
-};
+import { MenuProps } from './types';
+export declare const Menu: React.FC<MenuProps>;

package/dist/types/overlays/menu/types.d.ts

@@ -1,29 +1,24 @@
-import { ReactNode, ButtonHTMLAttributes, HTMLAttributes } from 'react';
+import { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
 export type MenuSize = 'sm' | 'md';
 /**
- * Props for MenuRoot
+ * Props for Menu
  */
-export interface MenuRootProps {
-    /** Menu children (Trigger, Content, etc) */
-    children: ReactNode;
-    /** open state */
+export interface MenuProps {
+    /** Whether the menu is open (controlled externally) */
     isOpen: boolean;
-    /** Callback when open state changes */
+    /** Callback when clicking outside menu */
     onOutsideClick: () => void;
     /** Menu size variant */
     size?: MenuSize;
-}
-/**
- * Props for MenuTrigger
- */
-export interface MenuTriggerProps extends HTMLAttributes<HTMLSpanElement> {
-    /** Trigger content */
+    /** Menu content (MenuContent/MenuItem) */
+    content: ReactNode;
+    /** Trigger element */
     children: ReactNode;
 }
 /**
  * Props for MenuContent
  */
-export interface MenuContentProps extends HTMLAttributes<HTMLDivElement> {
+export interface MenuContentProps extends HTMLAttributes<HTMLUListElement> {
     /** Menu items */
     children: ReactNode;
 }

package/dist/types/overlays/menu/use-menu.d.ts

@@ -1,3 +1,2 @@
 export declare function useMenuOutsideClick(isOpen: boolean, contentRef: React.RefObject<HTMLDivElement | null>, triggerRef: React.RefObject<HTMLButtonElement | null>, onOutsideClick: () => void): void;
 export declare function useMenuFocusFirstItem(isOpen: boolean, contentRef: React.RefObject<HTMLDivElement | null>): void;
-export declare function useMenuKeyboardNavigation(isOpen: boolean, contentRef: React.RefObject<HTMLDivElement | null>, triggerRef: React.RefObject<HTMLButtonElement | null>, onOutsideClick: () => void): void;

package/dist/types/overlays/modal/modal.d.ts

@@ -1,7 +1,16 @@
-import { FC } from 'react';
+import { default as React } from 'react';
 import { ModalRootProps } from './types';
-export declare const Modal: FC<ModalRootProps> & {
-    Header: import('react').ForwardRefExoticComponent<import('./types').ModalHeaderProps & import('react').RefAttributes<HTMLDivElement>>;
-    Body: import('react').ForwardRefExoticComponent<import('./types').ModalBodyProps & import('react').RefAttributes<HTMLDivElement>>;
-    Footer: import('react').ForwardRefExoticComponent<import('./types').ModalFooterProps & import('react').RefAttributes<HTMLDivElement>>;
+/**
+ * ModalRoot - A controlled modal overlay component
+ * Provides shared state and context for modal compound parts
+ */
+export declare const ModalRoot: React.FC<ModalRootProps>;
+/**
+ * Modal - Compound component with sub-components attached
+ * Provides a convenient API for using the modal with all its parts
+ */
+export declare const Modal: React.FC<ModalRootProps> & {
+    Header: React.ForwardRefExoticComponent<import('./types').ModalHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Body: React.ForwardRefExoticComponent<import('./types').ModalBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<import('./types').ModalFooterProps & React.RefAttributes<HTMLDivElement>>;
 };

package/dist/types/overlays/modal/types.d.ts

@@ -1,4 +1,5 @@
-import { HTMLAttributes } from 'react';
+import { OverlayPortalProps } from '../../utils/overlay-portal';
+import { HTMLAttributes, ReactNode } from 'react';
 /**
  * Modal component prop types
  */
@@ -7,27 +8,17 @@ export type ModalPlacement = 'top' | 'center';
 /**
  * Modal compound root
  */
-export interface ModalRootProps {
+export interface ModalRootProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, OverlayPortalProps {
     /** Controls whether the modal is open */
     isOpen: boolean;
-    /** Called when modal requests to close (ESC, overlay click) */
-    onOpenChange?: (open: boolean) => void;
+    /** Function to close the modal */
+    onClose: () => void;
     /** Modal size variant */
     size?: ModalSize;
     /** Modal placement variant */
     placement?: ModalPlacement;
     /** Children (Modal compound parts) */
-    children: React.ReactNode;
-    /** Optional: disables closing on overlay click */
-    disableOverlayClose?: boolean;
-    /** Optional: disables closing on ESC key */
-    disableEscClose?: boolean;
-    /** Optional: ARIA label for dialog */
-    'aria-label'?: string;
-    /** Optional: ARIA labelledby for dialog */
-    'aria-labelledby'?: string;
-    /** Optional: ARIA describedby for dialog */
-    'aria-describedby'?: string;
+    children: ReactNode;
 }
 /**
  * Props for Modal.Header, Modal.Footer
@@ -41,8 +32,4 @@ export interface ModalFooterProps extends HTMLAttributes<HTMLDivElement> {
 export interface ModalBodyProps extends HTMLAttributes<HTMLDivElement> {
     children: React.ReactNode;
 }
-export interface ModalOverlayProps extends HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
-    placement?: string;
-    onOverlayClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
-}
+export type ModalOverlayProps = Omit<HTMLAttributes<HTMLDivElement>, 'children'>;

package/dist/types/overlays/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { Tooltip } from './tooltip';
+export type * from './types';

package/dist/types/overlays/tooltip/tooltip.d.ts

@@ -0,0 +1,5 @@
+import { FC } from 'react';
+import { TooltipRootProps } from './types';
+export declare const Tooltip: FC<TooltipRootProps & {
+    delay?: number;
+}>;