neatkit 0.7.0 → 0.8.0

package/dist/Tooltip.js

@@ -1,6 +1,5 @@
 "use client";
-import { T as a, a as r } from "./Tooltip-CqWK_GRD.js";
+import { T as a } from "./Tooltip-BVqdnKK_.js";
 export {
-  a as TooltipProvider,
-  r as default
+  a as default
 };

package/dist/aria-Bntn6ad_.cjs

@@ -0,0 +1 @@
+"use strict";function r(e){return e!==void 0&&e!==!1&&e!=="false"}function s(e,t){return e?!0:t}function l(e,t){const n=(e==null?void 0:e.split(/\s+/).filter(Boolean))??[];return n.includes(t)||n.push(t),n.join(" ")}exports.hasInvalidState=r;exports.mergeIdentifiers=l;exports.resolveAriaInvalid=s;

package/dist/aria-CeA9QfD1.js

@@ -0,0 +1,15 @@
+function s(e) {
+  return e !== void 0 && e !== !1 && e !== "false";
+}
+function t(e, n) {
+  return e ? !0 : n;
+}
+function r(e, n) {
+  const o = (e == null ? void 0 : e.split(/\s+/).filter(Boolean)) ?? [];
+  return o.includes(n) || o.push(n), o.join(" ");
+}
+export {
+  s as h,
+  r as m,
+  t as r
+};

package/dist/components/Boundary/Boundary.d.ts

@@ -0,0 +1,65 @@
+import { type ComponentPropsWithRef, type ComponentPropsWithoutRef, type CSSProperties, type ElementType, type ReactElement } from "react";
+import "./styles/boundary.css";
+/** A type representing the themes supported by Boundary. */
+export type BoundaryTheme = "auto" | "light" | "dark";
+/** A type representing Boundary's visual background decoration. */
+export type BoundaryDecoration = "grid" | "none";
+/** A type representing Boundary's horizontal layout behavior. */
+export type BoundaryWidthMode = "narrow" | "full";
+/** A type representing Boundary's minimum-height behavior. */
+export type BoundaryHeightMode = "content" | "available" | "viewport";
+/** A type representing Boundary's spacing behavior on both axes. */
+export type BoundarySpacing = "standard" | "none";
+/** A type representing CSS custom properties accepted by Boundary styles. */
+type BoundaryCustomProperties = {
+    [CustomProperty in `--${string}`]?: string | number;
+};
+/** A type representing native Boundary styles and CSS custom properties. */
+type BoundaryStyle = CSSProperties & BoundaryCustomProperties;
+/** A type representing the reference accepted by a polymorphic element. */
+type BoundaryReference<Component extends ElementType> = ComponentPropsWithRef<Component>["ref"];
+/** A type representing properties owned by the Boundary component. */
+type BoundaryOwnProps = {
+    /** The color theme applied within Boundary. */
+    theme?: BoundaryTheme;
+    /** The accent color exposed to Boundary descendants. */
+    accent?: string;
+    /** The visual background treatment applied to Boundary. */
+    decoration?: BoundaryDecoration;
+    /** The horizontal layout applied to Boundary. */
+    width?: BoundaryWidthMode;
+    /** The minimum height applied to Boundary. */
+    height?: BoundaryHeightMode;
+    /** The spacing applied around content within Boundary. */
+    spacing?: BoundarySpacing;
+};
+/** A type representing properties for a polymorphic Boundary element. */
+export type BoundaryProps<Component extends ElementType = "div"> = BoundaryOwnProps & {
+    as?: Component;
+    style?: BoundaryStyle;
+} & Omit<ComponentPropsWithoutRef<Component>, keyof BoundaryOwnProps | "as" | "style">;
+/**
+ * A type representing the public polymorphic Boundary component.
+ *
+ * @param props - The properties accepted by the selected element.
+ *
+ * @returns The rendered Boundary element.
+ */
+type BoundaryComponent = <Component extends ElementType = "div">(props: BoundaryProps<Component> & {
+    ref?: BoundaryReference<Component>;
+}) => ReactElement | null;
+/**
+ * Renders a scoped Neatkit design-system boundary.
+ *
+ * Every Neatkit interface is wrapped in a Boundary. Portals, overlay
+ * stacking, dismissal precedence, and responsive measurement all resolve
+ * against the nearest boundary, so several independent boundaries may share
+ * one page. Where boundaries nest, descendants use the innermost one.
+ *
+ * @param props - The properties that configure Boundary and its root element.
+ * @param forwardedReference - The reference assigned to the root element.
+ *
+ * @returns The rendered Boundary element.
+ */
+declare const Boundary: BoundaryComponent;
+export default Boundary;

package/dist/components/Boundary/contexts/BoundaryContext.d.ts

@@ -0,0 +1,28 @@
+/** A type representing observable access to a boundary's measured width. */
+export type BoundaryWidthStore = {
+    /**
+     * Reads the boundary's measured content-box width.
+     *
+     * @returns The width in CSS pixels, or undefined while unmeasured.
+     */
+    read: () => number | undefined;
+    /**
+     * Subscribes a listener to changes in the measured width.
+     *
+     * @param listener - The listener notified after every measurement.
+     *
+     * @returns The teardown removing the registered listener.
+     */
+    subscribe: (listener: () => void) => () => void;
+};
+/** A type representing the Neatkit boundary shared with its descendants. */
+export type BoundaryContextValue = {
+    /** The Boundary root element descendants resolve against. */
+    boundaryElement: HTMLElement | null;
+    /** The element receiving overlays portalled inside the boundary. */
+    portalElement: HTMLElement | null;
+    /** Observable access to the boundary's measured content-box width. */
+    width: BoundaryWidthStore;
+};
+/** The internal React context published by each boundary. */
+export declare const BoundaryContext: import("react").Context<BoundaryContextValue | undefined>;

package/dist/components/Boundary/hooks/useBoundary.d.ts

@@ -0,0 +1,19 @@
+import { type BoundaryContextValue } from "../contexts/BoundaryContext";
+/**
+ * Returns the Neatkit boundary a component resolves against.
+ *
+ * Portals, overlay stacking, dismissal precedence, and responsive
+ * measurement all resolve against the nearest boundary, so a component
+ * requiring one cannot function without it. Naming the component requires
+ * the boundary, because the name exists only to report its absence; omitting
+ * the name returns whatever surrounds the caller, which suits a component
+ * that adapts to a boundary rather than depending on one.
+ *
+ * @param componentName - The component name reported when no boundary exists.
+ *
+ * @returns The nearest boundary, or undefined when none is required.
+ *
+ * @warning Throws when a named component is rendered outside a Boundary.
+ */
+export declare function useBoundary(componentName: string): BoundaryContextValue;
+export declare function useBoundary(): BoundaryContextValue | undefined;

package/dist/components/Boundary/hooks/useBoundaryWidth.d.ts

@@ -0,0 +1,23 @@
+import { type ForwardedRef, type RefCallback } from "react";
+import type { BoundaryWidthStore } from "../contexts/BoundaryContext";
+/** A type representing Boundary's measured layout state. */
+type BoundaryWidthMeasurement = {
+    /** The enhanced inner width, or undefined while CSS controls sizing. */
+    contentWidth: number | undefined;
+    /** Observable access to the boundary's measured content-box width. */
+    width: BoundaryWidthStore;
+    /** The mounted Boundary root, or null before it mounts. */
+    rootElement: HTMLElement | null;
+    /** The callback ref assigned to the Boundary root. */
+    rootReference: RefCallback<HTMLElement>;
+};
+/**
+ * Measures a Boundary root and publishes its layout to descendants.
+ *
+ * @param forwardedReference - The public reference assigned to the root.
+ * @param snap - Whether cell-aligned inner-width sizing is enabled.
+ *
+ * @returns The merged root reference and the measured boundary layout.
+ */
+export declare function useBoundaryWidth(forwardedReference: ForwardedRef<HTMLElement>, snap: boolean): BoundaryWidthMeasurement;
+export {};

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

@@ -0,0 +1,2 @@
+export { default } from "./Boundary";
+export type { BoundaryHeightMode, BoundaryDecoration, BoundaryProps, BoundarySpacing, BoundaryTheme, BoundaryWidthMode, } from "./Boundary";

package/dist/components/Boundary/utils/width.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Calculates the enhanced inner width for a Boundary root.
+ *
+ * Provides a centered cell-aligned width for eligible container sizes.
+ *
+ * @param availableWidth - The Boundary root's available content-box width.
+ * @param cellSize - The resolved grid cell size in CSS pixels.
+ *
+ * @returns The cell-aligned width, or undefined when CSS controls sizing.
+ */
+export declare function calculateBoundaryContentWidth(availableWidth: number, cellSize: number): number | undefined;

package/dist/components/Checkbox/Checkbox.d.ts

@@ -1,4 +1,5 @@
 import { type CSSProperties, type InputHTMLAttributes, type ReactNode } from "react";
+import CheckboxGroup from "./components/CheckboxGroup";
 import "./styles/checkbox.css";
 /** A type representing properties for the Checkbox component. */
 export type CheckboxProps = Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "style" | "type"> & {
@@ -22,7 +23,7 @@ export type CheckboxProps = Omit<InputHTMLAttributes<HTMLInputElement>, "childre
  *
  * @returns The rendered Checkbox control.
  */
-declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "className" | "style" | "children" | "type"> & {
+declare const CheckboxRoot: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "className" | "style" | "children" | "type"> & {
     /** The optional clickable and accessible label for the Checkbox. */
     children?: ReactNode;
     /** The additional class name applied to the Checkbox label root. */
@@ -32,4 +33,11 @@ declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<InputHTML
     /** The inline styles applied to the Checkbox label root. */
     style?: CSSProperties;
 } & import("react").RefAttributes<HTMLInputElement>>;
+/** A type representing the complete compound Checkbox component. */
+type CheckboxComponent = typeof CheckboxRoot & {
+    /** A labelled set of related Checkbox options sharing one name. */
+    Group: typeof CheckboxGroup;
+};
+/** The compound Checkbox component and its grouping form. */
+declare const Checkbox: CheckboxComponent;
 export default Checkbox;

package/dist/components/{CheckboxGroup → Checkbox/components}/CheckboxGroup.d.ts

@@ -1,8 +1,8 @@
 import { type ChangeEventHandler, type HTMLAttributes, type ReactNode } from "react";
-import "./styles/checkbox-group.css";
+import "../styles/checkbox-group.css";
 /** A type representing the visual direction of Checkbox options. */
 export type CheckboxGroupOrientation = "horizontal" | "vertical";
-/** A type representing properties for the CheckboxGroup component. */
+/** A type representing properties for the Checkbox.Group component. */
 export type CheckboxGroupProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> & {
     /**
      * The direct Checkbox options or fragments belonging to the group.

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

@@ -1,2 +1,3 @@
 export { default } from "./Checkbox";
 export type { CheckboxProps } from "./Checkbox";
+export type { CheckboxGroupOrientation, CheckboxGroupProps, } from "./components/CheckboxGroup";

package/dist/components/Checkbox/utils/checkbox-option.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Marks a component as a valid option inside a Checkbox group.
+ *
+ * The marker lets the group validate its children without importing the
+ * option component, which would otherwise create a circular dependency.
+ *
+ * @param component - The component receiving the internal option marker.
+ */
+export declare function markCheckboxOption<Component extends object>(component: Component): void;
+/**
+ * Determines whether a rendered child is a valid Checkbox group option.
+ *
+ * @param componentType - The rendered child component type to inspect.
+ *
+ * @returns Whether the component declares the internal option marker.
+ */
+export declare function isCheckboxOption(componentType: unknown): boolean;

package/dist/components/Icon/Icon.d.ts

@@ -1,5 +1,6 @@
 import { type SVGProps } from "react";
 import { type IconType } from "./utils/registry";
+import "./styles/icon.css";
 /** A type representing properties for the Icon component. */
 export type IconProps = Omit<SVGProps<SVGSVGElement>, "children" | "color" | "height" | "width"> & {
     /** The icon graphic rendered by the component. */

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

@@ -1,36 +1,3 @@
 export { default } from "./Icon";
 export type { IconProps } from "./Icon";
 export type { IconType } from "./utils/registry";
-export { default as ChatIcon } from "./icons/ChatIcon";
-export { default as ProjectsIcon } from "./icons/ProjectsIcon";
-export { default as ArticlesIcon } from "./icons/ArticlesIcon";
-export { default as MailIcon } from "./icons/MailIcon";
-export { default as GithubIcon } from "./icons/GithubIcon";
-export { default as GlobeIcon } from "./icons/GlobeIcon";
-export { default as LinkedInIcon } from "./icons/LinkedInIcon";
-export { default as RedditIcon } from "./icons/RedditIcon";
-export { default as ExitIcon } from "./icons/ExitIcon";
-export { default as CameraIcon } from "./icons/CameraIcon";
-export { default as QRCodeIcon } from "./icons/QRCodeIcon";
-export { default as DownloadIcon } from "./icons/DownloadIcon";
-export { default as SaveIcon } from "./icons/SaveIcon";
-export { default as PencilIcon } from "./icons/PencilIcon";
-export { default as ArrowLeftIcon } from "./icons/ArrowLeftIcon";
-export { default as ArrowRightIcon } from "./icons/ArrowRightIcon";
-export { default as CrossIcon } from "./icons/CrossIcon";
-export { default as CheckmarkIcon } from "./icons/CheckmarkIcon";
-export { default as PlusIcon } from "./icons/PlusIcon";
-export { default as MinusIcon } from "./icons/MinusIcon";
-export { default as WindowIcon } from "./icons/WindowIcon";
-export { default as UserIcon } from "./icons/UserIcon";
-export { default as DuplicateIcon } from "./icons/DuplicateIcon";
-export { default as EyeIcon } from "./icons/EyeIcon";
-export { default as EyeOffIcon } from "./icons/EyeOffIcon";
-export { default as SignalIcon } from "./icons/SignalIcon";
-export { default as AudioIcon } from "./icons/AudioIcon";
-export { default as HardwareIcon } from "./icons/HardwareIcon";
-export { default as BurgerIcon } from "./icons/BurgerIcon";
-export { default as RepositoryIcon } from "./icons/RepositoryIcon";
-export { default as KeyIcon } from "./icons/KeyIcon";
-export { default as InfoIcon } from "./icons/InfoIcon";
-export { default as WarningIcon } from "./icons/WarningIcon";

package/dist/components/Input/Input.d.ts

@@ -1,4 +1,4 @@
-import { type CSSProperties, type InputHTMLAttributes, type ReactNode } from "react";
+import { type CSSProperties, type InputHTMLAttributes } from "react";
 import "./styles/input.css";
 /** A type representing the supported native single-line input types. */
 export type InputType = "email" | "number" | "password" | "search" | "tel" | "text" | "url";
@@ -10,12 +10,8 @@ export type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "children"
     clearable?: boolean;
     /** Whether the Input exposes an invalid semantic and visual state. */
     invalid?: boolean;
-    /** The content displayed before the editable value. */
-    leading?: ReactNode;
     /** Whether the Input displays a loading indicator and blocks editing. */
     loading?: boolean;
-    /** The content displayed after the editable value. */
-    trailing?: ReactNode;
     /** The inline styles applied to the composite Input root. */
     style?: CSSProperties;
     /** The supported native behavior applied to the single-line control. */
@@ -36,12 +32,8 @@ declare const Input: import("react").ForwardRefExoticComponent<Omit<InputHTMLAtt
     clearable?: boolean;
     /** Whether the Input exposes an invalid semantic and visual state. */
     invalid?: boolean;
-    /** The content displayed before the editable value. */
-    leading?: ReactNode;
     /** Whether the Input displays a loading indicator and blocks editing. */
     loading?: boolean;
-    /** The content displayed after the editable value. */
-    trailing?: ReactNode;
     /** The inline styles applied to the composite Input root. */
     style?: CSSProperties;
     /** The supported native behavior applied to the single-line control. */

package/dist/components/Modal/Modal.d.ts

@@ -18,8 +18,6 @@ export type ModalProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onCl
     onClose?: (reason: ModalCloseReason) => void;
     /** Whether the Modal is currently open. */
     open: boolean;
-    /** The optional element receiving the Modal portal. */
-    portalContainer?: Element | null;
     /** Whether focus returns to its prior owner when the Modal closes. */
     restoreFocus?: boolean;
     /** Whether keyboard and programmatic focus remain inside the Modal. */
@@ -50,8 +48,6 @@ declare const Modal: import("react").ForwardRefExoticComponent<Omit<HTMLAttribut
     onClose?: (reason: ModalCloseReason) => void;
     /** Whether the Modal is currently open. */
     open: boolean;
-    /** The optional element receiving the Modal portal. */
-    portalContainer?: Element | null;
     /** Whether focus returns to its prior owner when the Modal closes. */
     restoreFocus?: boolean;
     /** Whether keyboard and programmatic focus remain inside the Modal. */

package/dist/components/PinInput/PinInput.d.ts

@@ -47,7 +47,7 @@ export type PinInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "childre
  *
  * @returns The rendered PinInput control.
  */
-declare const PinInput: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "className" | "style" | "inputMode" | "children" | "onPaste" | "onChange" | "size" | "type" | "pattern" | "value" | "maxLength" | "minLength"> & {
+declare const PinInput: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "className" | "style" | "inputMode" | "children" | "onPaste" | "onChange" | "size" | "pattern" | "type" | "value" | "maxLength" | "minLength"> & {
     /** The additional class name applied to the composite PinInput root. */
     className?: string;
     /** Whether entered characters are visually replaced with centered dots. */

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

@@ -32,10 +32,8 @@ export type PopoverProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "de
     onPointerDownOutside?: (event: PointerEvent) => void;
     /** The controlled open state of the Popover. */
     open?: boolean;
-    /** The preferred placement before viewport collision handling. */
+    /** The preferred placement before collision handling. */
     placement?: PopoverPlacement;
-    /** The optional element receiving the Popover portal. */
-    portalContainer?: Element | null;
     /** Whether focus returns to the trigger after non-outside closure. */
     restoreFocus?: boolean;
     /** Whether keyboard and programmatic focus remain inside the Popover. */
@@ -85,10 +83,8 @@ declare const Popover: import("react").ForwardRefExoticComponent<Omit<HTMLAttrib
     onPointerDownOutside?: (event: PointerEvent) => void;
     /** The controlled open state of the Popover. */
     open?: boolean;
-    /** The preferred placement before viewport collision handling. */
+    /** The preferred placement before collision handling. */
     placement?: PopoverPlacement;
-    /** The optional element receiving the Popover portal. */
-    portalContainer?: Element | null;
     /** Whether focus returns to the trigger after non-outside closure. */
     restoreFocus?: boolean;
     /** Whether keyboard and programmatic focus remain inside the Popover. */

package/dist/components/Portal/Portal.d.ts

@@ -3,17 +3,20 @@ import { type ReactNode } from "react";
 type PortalProps = {
     /** The content rendered outside its React layout parent. */
     children: ReactNode;
-    /** The optional element receiving the portal content. */
-    container?: Element | null;
-    /** The optional element whose inherited Neatkit variables are preserved. */
-    inheritFrom?: HTMLElement | null;
 };
 /**
- * Renders content into a browser-owned container after hydration.
+ * Renders content into its boundary after hydration.
  *
- * @param props - The portal destination, design source, and content.
+ * Portalling inside the boundary keeps design tokens inheriting through the
+ * cascade, so the portalled subtree needs no copied design context. The
+ * destination is never configurable, and the boundary is required rather
+ * than preferred: overlay coordinates are measured as offsets from it, so a
+ * portal that quietly fell back to the document would position its content
+ * wrongly instead of reporting the mistake.
  *
- * @returns A server-safe source marker and the mounted browser portal.
+ * @param props - The portalled content.
+ *
+ * @returns The mounted browser portal.
  */
-export default function Portal(props: PortalProps): import("react").JSX.Element;
+export default function Portal(props: PortalProps): import("react").ReactPortal | null;
 export {};

package/dist/components/Portal/hooks/useDismissableLayer.d.ts

@@ -9,6 +9,8 @@ type DismissableLayerOptions = {
     dismissOnPointerDownOutside?: boolean;
     /** The boundaries considered part of the layer. */
     boundaries: readonly RefObject<HTMLElement | null>[];
+    /** The boundary owning the layer's overlay stack. */
+    boundary: Element | null;
     /** The stable overlay stack identifier for the layer. */
     layerId: symbol;
     /** The document owning the layer and its event listeners. */

package/dist/components/Portal/hooks/useFloatingPosition.d.ts

@@ -1,12 +1,13 @@
 import { type FloatingPlacement, type FloatingPosition } from "../utils/floating-position";
 /**
- * Keeps anchored floating content aligned and inside its viewport.
+ * Keeps anchored floating content aligned and inside its boundary.
  *
  * @param active - Whether positioning observers should remain active.
  * @param placement - The preferred floating placement.
  * @param trigger - The element anchoring the floating panel.
  * @param panel - The mounted floating panel.
+ * @param boundary - The boundary the panel is positioned within.
  *
- * @returns The current fixed-position coordinates and resolved placement.
+ * @returns The boundary-relative coordinates and resolved placement.
  */
-export declare function useFloatingPosition(active: boolean, placement: FloatingPlacement, trigger: HTMLElement | null, panel: HTMLElement | null): FloatingPosition | null;
+export declare function useFloatingPosition(active: boolean, placement: FloatingPlacement, trigger: HTMLElement | null, panel: HTMLElement | null, boundary: HTMLElement | null): FloatingPosition | null;

package/dist/components/Portal/hooks/useFocusTrap.d.ts

@@ -6,6 +6,8 @@ type FocusTrapOptions = {
     active: boolean;
     /** Whether focus moves inside the trap when it activates. */
     autoFocus?: boolean;
+    /** The boundary owning the trapped layer's overlay stack. */
+    boundary: Element | null;
     /** The element containing focus while the trap is active. */
     container: HTMLElement | null;
     /** The optional preferred element focused when the trap opens. */

package/dist/components/Portal/hooks/useScrollLock.d.ts

@@ -1,7 +1,13 @@
 /**
- * Locks document scrolling while compensating for the removed scrollbar.
+ * Locks the scroller enclosing a boundary while compensating its scrollbar.
+ *
+ * The lock follows the boundary like every other overlay concern. A boundary
+ * occupying the page locks the page, and a boundary embedded in its own
+ * scroller locks only that scroller, so an overlay never freezes a host
+ * interface it does not own. `lockScroll` disables it entirely.
  *
  * @param active - Whether the lock should currently apply.
- * @param ownerDocument - The document whose body scrolling is controlled.
+ * @param ownerDocument - The document containing the boundary.
+ * @param boundary - The boundary owning the overlay requesting the lock.
  */
-export declare function useScrollLock(active: boolean, ownerDocument: Document | null): void;
+export declare function useScrollLock(active: boolean, ownerDocument: Document | null, boundary: Element | null): void;

package/dist/components/Portal/utils/boundary-focus.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Determines whether an overlay outside this layer's boundary owns focus.
+ *
+ * @param ownerDocument - The document owning the focused element.
+ * @param boundary - The boundary owning the inspected layer.
+ *
+ * @returns Whether a competing overlay currently owns focus.
+ */
+export declare function isFocusInsideAnotherOverlay(ownerDocument: Document, boundary: Element): boolean;
+/**
+ * Determines whether an overlay outside this layer's boundary owns a press.
+ *
+ * Pointer ownership cannot be resolved through the focused element, because a
+ * capture-phase pointer press runs before focus moves to the pressed target.
+ * A layer reading focus here would still see its own content and claim a
+ * press that belongs to a competing boundary, so the pressed node decides.
+ *
+ * @param target - The node receiving the pointer press.
+ * @param boundary - The boundary owning the inspected layer.
+ *
+ * @returns Whether a competing overlay currently owns the press.
+ */
+export declare function isPointerInsideAnotherOverlay(target: Node | null, boundary: Element): boolean;

package/dist/components/Portal/utils/floating-position.d.ts

@@ -4,23 +4,57 @@ export type FloatingPlacement = "bottom" | "left" | "right" | "top";
 export type FloatingPosition = {
     /** The cross-axis offset at which the arrow points to the trigger. */
     arrowOffset: number;
-    /** The resolved placement after viewport collision handling. */
+    /** The resolved placement after boundary collision handling. */
     placement: FloatingPlacement;
-    /** The viewport-relative horizontal position. */
+    /** The boundary-relative horizontal position. */
     left: number;
-    /** The viewport-relative vertical position. */
+    /** The boundary-relative vertical position. */
     top: number;
 };
 /**
- * Calculates collision-aware floating coordinates within a viewport.
+ * A type representing the edges a rectangle is fitted against.
+ *
+ * Only edges are ever read, and describing them structurally keeps the
+ * geometry independent of any realm: a `DOMRect` from any document
+ * satisfies it, and a fitted result needs no constructor to build.
+ */
+export type EdgeBounds = {
+    /** The distance from the coordinate space's top to the lower edge. */
+    bottom: number;
+    /** The distance from the coordinate space's left to the leading edge. */
+    left: number;
+    /** The distance from the coordinate space's left to the trailing edge. */
+    right: number;
+    /** The distance from the coordinate space's top to the upper edge. */
+    top: number;
+};
+/**
+ * Narrows a boundary to the part of it the viewer can actually see.
+ *
+ * A boundary taller or wider than the viewport still reports its full size,
+ * so fitting against it alone can place a panel in boundary space that is
+ * scrolled out of view. Collision detection therefore runs against the
+ * visible intersection, while coordinates stay relative to the boundary.
+ *
+ * @param boundaryBounds - The boundary bounds in viewport coordinates.
+ * @param viewportWidth - The visible viewport width in CSS pixels.
+ * @param viewportHeight - The visible viewport height in CSS pixels.
+ *
+ * @returns The visible region, or the boundary when nothing intersects.
+ */
+export declare function getVisibleBounds(boundaryBounds: EdgeBounds, viewportWidth: number, viewportHeight: number): EdgeBounds;
+/**
+ * Calculates collision-aware floating coordinates within a boundary.
+ *
+ * Every rectangle is expressed in the same coordinate space, so the returned
+ * coordinates share that space and callers convert them once.
  *
  * @param placement - The preferred floating placement.
- * @param spacing - The minimum distance from triggers and viewport edges.
- * @param triggerBounds - The viewport bounds of the anchoring trigger.
+ * @param spacing - The minimum distance from triggers and boundary edges.
+ * @param triggerBounds - The bounds of the anchoring trigger.
  * @param panelBounds - The measured bounds of the floating panel.
- * @param viewportWidth - The available viewport width.
- * @param viewportHeight - The available viewport height.
+ * @param boundaryBounds - The bounds the panel must remain inside.
  *
  * @returns The fitted coordinates and resolved floating placement.
  */
-export declare function calculateFloatingPosition(placement: FloatingPlacement, spacing: number, triggerBounds: DOMRect, panelBounds: DOMRect, viewportWidth: number, viewportHeight: number): FloatingPosition;
+export declare function calculateFloatingPosition(placement: FloatingPlacement, spacing: number, triggerBounds: DOMRect, panelBounds: DOMRect, boundaryBounds: EdgeBounds): FloatingPosition;

package/dist/components/Portal/utils/overlay-stack.d.ts

@@ -6,23 +6,35 @@ export type OverlayLayer = {
     zIndex: number;
 };
 /**
- * Registers an active layer in its owning document's overlay stack.
+ * Registers an active layer in its owning boundary's overlay stack.
  *
  * @param active - Whether the layer currently participates in the stack.
- * @param ownerDocument - The document owning the layer.
+ * @param boundaryElement - The boundary owning the layer.
  *
  * @returns The stable layer identifier and its current z-index.
  */
-export declare function useOverlayLayer(active: boolean, ownerDocument: Document | null): OverlayLayer;
+export declare function useOverlayLayer(active: boolean, boundaryElement: Element | null): OverlayLayer;
 /**
- * Determines whether a layer is uppermost in its document.
+ * Determines whether a layer is uppermost in its boundary.
  *
- * @param ownerDocument - The document owning the overlay layer.
+ * @param boundaryElement - The boundary owning the overlay layer.
  * @param layerIdentifier - The layer identifier being inspected.
  *
  * @returns Whether the layer is the last active stack entry.
  */
-export declare function isTopmostOverlayLayer(ownerDocument: Document, layerIdentifier: symbol): boolean;
+export declare function isTopmostOverlayLayer(boundaryElement: Element, layerIdentifier: symbol): boolean;
+/**
+ * Determines whether a boundary currently owns any active overlay layer.
+ *
+ * The lookup deliberately avoids creating an entry, because this answers a
+ * question about boundaries the caller does not own, and creating one for
+ * every boundary inspected would populate the map with empty stacks.
+ *
+ * @param boundaryElement - The boundary whose overlay stack is inspected.
+ *
+ * @returns Whether the boundary holds at least one registered layer.
+ */
+export declare function hasActiveOverlayLayer(boundaryElement: Element): boolean;
 /**
  * Registers whether an overlay layer currently owns focus containment.
  *
@@ -30,16 +42,16 @@ export declare function isTopmostOverlayLayer(ownerDocument: Document, layerIden
  * a non-trapping child layer cannot suspend its enclosing focus trap.
  *
  * @param active - Whether the layer currently contains focus.
- * @param ownerDocument - The document owning the layer.
+ * @param boundaryElement - The boundary owning the layer.
  * @param layerIdentifier - The layer identifier registered in the stack.
  */
-export declare function useOverlayFocusLayer(active: boolean, ownerDocument: Document | null, layerIdentifier: symbol): void;
+export declare function useOverlayFocusLayer(active: boolean, boundaryElement: Element | null, layerIdentifier: symbol): void;
 /**
  * Determines whether a layer is the uppermost focus-containing overlay.
  *
- * @param ownerDocument - The document owning the overlay layer.
+ * @param boundaryElement - The boundary owning the overlay layer.
  * @param layerIdentifier - The layer identifier being inspected.
  *
  * @returns Whether no later visual layer also owns focus containment.
  */
-export declare function isTopmostFocusLayer(ownerDocument: Document, layerIdentifier: symbol): boolean;
+export declare function isTopmostFocusLayer(boundaryElement: Element, layerIdentifier: symbol): boolean;