@react-hive/honey-layout 6.2.0 → 6.5.0

package/dist/components/HoneyContextMenu/HoneyContextMenu.d.ts

@@ -1,10 +1,11 @@
 import { ReactNode } from 'react';
+import { ReferenceType } from '@floating-ui/react';
 import { FastOmit } from '@react-hive/honey-style';
-import { HoneyPopupProps, HoneyPopupChildrenContextProps } from '../HoneyPopup';
+import { HoneyPopupContextValue, HoneyPopupProps } from '../HoneyPopup';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
 import { HoneyContextMenuContentProps } from './HoneyContextMenuContent';
-export interface HoneyContextMenuProps<Option extends HoneyContextMenuOption<Context>, Context = undefined, UseAutoSize extends boolean = boolean> extends FastOmit<HoneyPopupProps<Context, UseAutoSize>, 'content'>, Pick<HoneyContextMenuContentProps<Option, Context>, 'options' | 'optionProps'> {
-    children: (context: HoneyPopupChildrenContextProps) => ReactNode;
-    subProps?: FastOmit<HoneyContextMenuContentProps<Option, Context>, 'options' | 'optionProps'>;
+export interface HoneyContextMenuProps<Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType, UseAutoSize extends boolean> extends FastOmit<HoneyPopupProps<Context, Reference, UseAutoSize>, 'content'>, Pick<HoneyContextMenuContentProps<Option, Context, Reference, UseAutoSize>, 'options' | 'optionProps'> {
+    children: ReactNode | ((context: HoneyPopupContextValue<Context, Reference>) => ReactNode);
+    subProps?: FastOmit<HoneyContextMenuContentProps<Option, Context, Reference, UseAutoSize>, 'options' | 'optionProps'>;
 }
-export declare const HoneyContextMenu: <Option extends HoneyContextMenuOption<Context>, Context = undefined, UseAutoSize extends boolean = boolean>({ children, subProps, options, optionProps, clickOptions, context, ...popupProps }: HoneyContextMenuProps<Option, Context, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenu: <Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType, UseAutoSize extends boolean>({ children, subProps, options, optionProps, clickOptions, context, ...popupProps }: HoneyContextMenuProps<Option, Context, Reference, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyContextMenu/HoneyContextMenu.types.d.ts

@@ -1,11 +1,13 @@
-interface HoneyContextMenuOptionExecutionContext<Context> {
+import { FloatingContext, ReferenceType } from '@floating-ui/react';
+interface HoneyContextMenuOptionExecutionContext<Context, Reference extends ReferenceType> {
     context: Context | undefined;
+    floatingContext: FloatingContext<Reference>;
 }
-export interface HoneyContextMenuOption<Context = undefined> {
+export interface HoneyContextMenuOption<Context = undefined, Reference extends ReferenceType = ReferenceType> {
     id: string;
     label: string;
-    options?: HoneyContextMenuOption<Context>[];
-    visible?: boolean | ((executionContext: HoneyContextMenuOptionExecutionContext<Context>) => boolean);
-    onClick?: (executionContext: HoneyContextMenuOptionExecutionContext<Context>) => void;
+    options?: HoneyContextMenuOption<Context, Reference>[];
+    visible?: boolean | ((executionContext: HoneyContextMenuOptionExecutionContext<Context, Reference>) => boolean);
+    onClick?: (executionContext: HoneyContextMenuOptionExecutionContext<Context, Reference>) => void;
 }
 export {};

package/dist/components/HoneyContextMenu/HoneyContextMenuContent.d.ts

@@ -1,9 +1,10 @@
+import { ReferenceType } from '@floating-ui/react';
 import { FastOmit } from '@react-hive/honey-style';
 import { HoneyPopupProps } from '../HoneyPopup';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
 import { HoneyContextMenuContentOptionProps } from './HoneyContextMenuContentOption';
-export interface HoneyContextMenuContentProps<Option extends HoneyContextMenuOption<Context>, Context> extends FastOmit<HoneyPopupProps<Context>, 'children' | 'context' | 'content'> {
+export interface HoneyContextMenuContentProps<Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType, UseAutoSize extends boolean> extends FastOmit<HoneyPopupProps<Context, Reference, UseAutoSize>, 'children' | 'context' | 'content'> {
     options: Option[] | undefined;
-    optionProps?: FastOmit<HoneyContextMenuContentOptionProps<Option, Context>, 'option'>;
+    optionProps?: FastOmit<HoneyContextMenuContentOptionProps<Option, Context, Reference>, 'option'>;
 }
-export declare const HoneyContextMenuContent: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ options, optionProps, floatingOptions, ...popupProps }: HoneyContextMenuContentProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenuContent: <Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType, UseAutoSize extends boolean>({ options, optionProps, floatingOptions, ...popupProps }: HoneyContextMenuContentProps<Option, Context, Reference, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyContextMenu/HoneyContextMenuContentOption.d.ts

@@ -1,6 +1,7 @@
+import { ReferenceType } from '@floating-ui/react';
 import { HoneyBoxProps } from '../HoneyBox';
 import { HoneyContextMenuOption } from './HoneyContextMenu.types';
-export interface HoneyContextMenuContentOptionProps<Option extends HoneyContextMenuOption<Context>, Context> extends HoneyBoxProps {
+export interface HoneyContextMenuContentOptionProps<Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType> extends HoneyBoxProps {
     option: Option;
 }
-export declare const HoneyContextMenuContentOption: <Option extends HoneyContextMenuOption<Context>, Context>({ option, ...props }: HoneyContextMenuContentOptionProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;
+export declare const HoneyContextMenuContentOption: <Option extends HoneyContextMenuOption<Context, Reference>, Context, Reference extends ReferenceType>({ option, ...props }: HoneyContextMenuContentOptionProps<Option, Context, Reference>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyPopup/HoneyPopup.d.ts

@@ -1,57 +1,21 @@
-import { CSSProperties, ReactNode } from 'react';
-import { UseInteractionsReturn, FloatingArrowProps, FloatingFocusManagerProps, MiddlewareData } from '@floating-ui/react';
-import { FastOmit } from '@react-hive/honey-style';
-import { HoneyPopupPortalProps } from './HoneyPopupPortal';
-import { HoneyPopupStyledProps } from './HoneyPopupStyled';
-import { HoneyPopupContextProps } from './HoneyPopupContext';
-import { UseHoneyPopupOptions } from './hooks';
-import { HoneyOverlayProps } from '../HoneyOverlay';
-export interface HoneyPopupChildrenContextProps {
-    referenceProps: ReturnType<UseInteractionsReturn['getReferenceProps']>;
-}
-type InheritedHoneyOverlayProps = FastOmit<HoneyOverlayProps, 'children' | 'active' | 'onDeactivate' | '$position'>;
-export interface HoneyPopupProps<Context = undefined, UseAutoSize extends boolean = boolean> extends UseHoneyPopupOptions<UseAutoSize> {
-    children: (context: HoneyPopupChildrenContextProps) => ReactNode;
-    referenceProps?: FastOmit<HoneyPopupStyledProps, 'children' | 'content'>;
-    /**
-     * Content inside the popup.
-     */
-    content: ReactNode | ((context: HoneyPopupContextProps<Context>) => ReactNode);
+import { ReferenceType } from '@floating-ui/react';
+import { HoneyPopupContentProps } from './HoneyPopupContent';
+export interface HoneyPopupProps<Context, Reference extends ReferenceType, UseAutoSize extends boolean> extends HoneyPopupContentProps<Context, Reference, UseAutoSize> {
     /**
-     * Additional props for the floating content.
-     */
-    contentProps?: UseAutoSize extends true ? Omit<InheritedHoneyOverlayProps, '$minWidth' | '$minHeight' | '$maxWidth' | '$maxHeight'> : InheritedHoneyOverlayProps;
-    /**
-     * Props for managing focus inside the popup.
+     * Whether to wrap the popup in a `FloatingTree`.
+     * Required if you're using nested floating elements like tooltips or popups within a popup.
      *
-     * @see https://floating-ui.com/docs/floatingfocusmanager#props
-     */
-    focusManagerProps?: FastOmit<FloatingFocusManagerProps, 'children' | 'context'>;
-    /**
-     * Properties for an arrow component.
+     * @default false
      *
-     * @see https://floating-ui.com/docs/FloatingArrow#props
-     */
-    arrowProps?: FastOmit<FloatingArrowProps, 'ref' | 'context'>;
-    /**
-     * Properties for `HoneyPopupPortal` component.
-     */
-    portalProps?: FastOmit<HoneyPopupPortalProps, 'children'>;
-    /**
-     * Function to adjust the floating content's styles before rendering.
-     */
-    adjustStyles?: (styles: CSSProperties, executionContext: {
-        middlewareData: MiddlewareData;
-    }) => CSSProperties;
-    /**
-     * Optional context for the popup.
+     * @see https://floating-ui.com/docs/floatingtree
      */
-    context?: Context;
+    useTree?: boolean;
 }
 /**
  * A popup component that provides floating behavior with customizable options.
  *
- * @template Context - Optional context type.
+ * @template Context - Optional context type passed to floating UI.
+ * @template Reference - The reference type used for positioning.
+ * @template UseAutoSize - Enables auto-sizing behavior for content if `true`.
  */
-export declare const HoneyPopup: <Context = undefined, UseAutoSize extends boolean = boolean>({ children, referenceProps, content, contentProps, focusManagerProps, arrowProps, portalProps, adjustStyles, context, ...popupOptions }: HoneyPopupProps<Context, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const HoneyPopup: <Context, Reference extends ReferenceType, UseAutoSize extends boolean>({ useTree, ...props }: HoneyPopupProps<Context, Reference, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/HoneyPopup/HoneyPopup.types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/HoneyPopup/HoneyPopupContent.d.ts

@@ -0,0 +1,49 @@
+import { CSSProperties, ReactNode } from 'react';
+import { ReferenceType, FloatingArrowProps, FloatingFocusManagerProps, MiddlewareData } from '@floating-ui/react';
+import { FastOmit } from '@react-hive/honey-style';
+import { HoneyPopupPortalProps } from './HoneyPopupPortal';
+import { HoneyPopupStyledProps } from './HoneyPopupStyled';
+import { HoneyPopupContextValue } from './HoneyPopupContext';
+import { UseHoneyPopupOptions } from './hooks';
+import { HoneyOverlayProps } from '../HoneyOverlay';
+type InheritedHoneyOverlayProps = FastOmit<HoneyOverlayProps, 'children' | 'active' | 'onDeactivate' | '$position'>;
+export interface HoneyPopupContentProps<Context, Reference extends ReferenceType, UseAutoSize extends boolean> extends UseHoneyPopupOptions<Reference, UseAutoSize> {
+    children: ReactNode | ((context: HoneyPopupContextValue<Context, Reference>) => ReactNode);
+    referenceProps?: FastOmit<HoneyPopupStyledProps, 'children' | 'content'>;
+    /**
+     * Content inside the popup.
+     */
+    content: ReactNode | ((context: HoneyPopupContextValue<Context, Reference>) => ReactNode);
+    /**
+     * Additional props for the floating content.
+     */
+    contentProps?: UseAutoSize extends true ? FastOmit<InheritedHoneyOverlayProps, '$minWidth' | '$minHeight' | '$maxWidth' | '$maxHeight'> : InheritedHoneyOverlayProps;
+    /**
+     * Props for managing focus inside the popup.
+     *
+     * @see https://floating-ui.com/docs/floatingfocusmanager#props
+     */
+    focusManagerProps?: FastOmit<FloatingFocusManagerProps, 'children' | 'context'>;
+    /**
+     * Properties for an arrow component.
+     *
+     * @see https://floating-ui.com/docs/FloatingArrow#props
+     */
+    arrowProps?: FastOmit<FloatingArrowProps, 'ref' | 'context'>;
+    /**
+     * Properties for `HoneyPopupPortal` component.
+     */
+    portalProps?: FastOmit<HoneyPopupPortalProps, 'children'>;
+    /**
+     * Function to adjust the floating content's styles before rendering.
+     */
+    adjustStyles?: (styles: CSSProperties, executionContext: {
+        middlewareData: MiddlewareData;
+    }) => CSSProperties;
+    /**
+     * Optional context for the popup.
+     */
+    context?: Context;
+}
+export declare const HoneyPopupContent: <Context, Reference extends ReferenceType, UseAutoSize extends boolean>({ children, referenceProps, content, contentProps, focusManagerProps, arrowProps, portalProps, adjustStyles, context, ...popupOptions }: HoneyPopupContentProps<Context, Reference, UseAutoSize>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/HoneyPopup/HoneyPopupContext.d.ts

@@ -1,4 +1,6 @@
-export interface HoneyPopupContextProps<Context> {
+import { FloatingContext, ReferenceType } from '@floating-ui/react';
+export interface HoneyPopupContextValue<Context, Reference extends ReferenceType> {
     context: Context | undefined;
+    floatingContext: FloatingContext<Reference>;
 }
-export declare const HoneyPopupContext: import('react').Context<HoneyPopupContextProps<any> | undefined>;
+export declare const HoneyPopupContext: import('react').Context<HoneyPopupContextValue<any, any> | undefined>;

package/dist/components/HoneyPopup/HoneyPopupTree.d.ts

@@ -3,4 +3,19 @@ import { FloatingTreeProps } from '@floating-ui/react';
 /**
  * @see https://floating-ui.com/docs/floatingtree
  */
-export declare const HoneyPopupTree: ({ children, ...props }: FloatingTreeProps) => string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+interface HoneyPopupTreeProps extends FloatingTreeProps {
+    /**
+     * Whether to render the `FloatingTree` component.
+     * Automatically disables if there is a parent floating node.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Wrapper component for `FloatingTree` that conditionally renders based on whether there is a parent floating node.
+ *
+ * @see https://floating-ui.com/docs/floatingtree
+ */
+export declare const HoneyPopupTree: ({ children, enabled, ...props }: HoneyPopupTreeProps) => string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

package/dist/components/HoneyPopup/hooks/use-honey-popup-context.d.ts

@@ -1 +1,3 @@
-export declare const useHoneyPopupContext: () => import('../HoneyPopupContext').HoneyPopupContextProps<any>;
+import { ReferenceType } from '@floating-ui/react';
+import { HoneyPopupContextValue } from '../HoneyPopupContext';
+export declare const useHoneyPopupContext: <Context, Reference extends ReferenceType = ReferenceType>() => HoneyPopupContextValue<Context, Reference>;

package/dist/components/HoneyPopup/hooks/use-honey-popup-interactions.d.ts

@@ -1,5 +1,6 @@
-import { FloatingContext, UseDismissProps, UseClickProps, UseHoverProps, UseFocusProps, UseClientPointProps, UseRoleProps } from '@floating-ui/react';
+import { ElementProps, ReferenceType, FloatingContext, UseDismissProps, UseClickProps, UseHoverProps, UseFocusProps, UseClientPointProps, UseRoleProps } from '@floating-ui/react';
 import { FastOmit } from '@react-hive/honey-style';
+export type HoneyPopupExtraInteraction = <Props extends object>(context: FloatingContext, props?: Props) => ElementProps;
 /**
  * Options for configuring popup interactions.
  */
@@ -53,5 +54,16 @@ export interface UseHoneyPopupInteractionsOptions {
      * @see https://floating-ui.com/docs/userole
      */
     roleOptions?: FastOmit<UseRoleProps, 'enabled'>;
+    /**
+     * Additional custom interactions to be merged with default ones.
+     * Useful for extending or overriding the default behavior.
+     *
+     * To define custom interaction, please use the ` HoneyPopupExtraInteraction ` type.
+     *
+     * @default []
+     *
+     * @see https://floating-ui.com/docs/custom-hooks
+     */
+    extraInteractions?: ElementProps[];
 }
-export declare const useHoneyPopupInteractions: (context: FloatingContext, { enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, }: UseHoneyPopupInteractionsOptions) => import('@floating-ui/react').UseInteractionsReturn;
+export declare const useHoneyPopupInteractions: <Reference extends ReferenceType>(context: FloatingContext<Reference>, { enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, extraInteractions, }: UseHoneyPopupInteractionsOptions) => import('@floating-ui/react').UseInteractionsReturn;

package/dist/components/HoneyPopup/hooks/use-honey-popup.d.ts

@@ -1,15 +1,21 @@
-import { useTransitionStyles, AutoUpdateOptions, AutoPlacementOptions, ArrowOptions, FlipOptions, OffsetOptions, ShiftOptions, OpenChangeReason, UseFloatingOptions, UseFloatingReturn, UseInteractionsReturn, UseTransitionStylesProps } from '@floating-ui/react';
+import { useTransitionStyles, ReferenceType, AutoUpdateOptions, AutoPlacementOptions, ArrowOptions, FlipOptions, OffsetOptions, ShiftOptions, OpenChangeReason, UseFloatingOptions, UseFloatingReturn, UseInteractionsReturn, UseTransitionStylesProps } from '@floating-ui/react';
 import { RefObject } from 'react';
 import { Derivable } from '@floating-ui/dom';
 import { FastOmit } from '@react-hive/honey-style';
 import { Nullable } from '../../../types';
 import { UseHoneyPopupInteractionsOptions } from './use-honey-popup-interactions';
-export interface UseHoneyPopupOptions<UseAutoSize extends boolean = boolean> extends UseHoneyPopupInteractionsOptions {
+export interface UseHoneyPopupOptions<Reference extends ReferenceType, UseAutoSize extends boolean = boolean> extends UseHoneyPopupInteractionsOptions {
     open?: boolean;
     /**
      * Options for configuring the floating UI behavior.
      */
-    floatingOptions?: FastOmit<UseFloatingOptions, 'nodeId' | 'open' | 'whileElementsMounted' | 'onOpenChange'>;
+    floatingOptions?: FastOmit<UseFloatingOptions<Reference>, 'nodeId' | 'open' | 'whileElementsMounted' | 'onOpenChange'>;
+    /**
+     * Whether to use the offset middleware.
+     *
+     * @default true
+     */
+    useOffset?: boolean;
     /**
      * Configuration for offset middleware.
      *
@@ -115,7 +121,7 @@ export interface UseHoneyPopupOptions<UseAutoSize extends boolean = boolean> ext
      */
     onClose?: (reason?: OpenChangeReason, event?: Event) => void;
 }
-interface UseHoneyPopupApi {
+interface UseHoneyPopupApi<Reference extends ReferenceType> {
     /**
      * Unique identifier for the floating element.
      */
@@ -127,7 +133,7 @@ interface UseHoneyPopupApi {
     /**
      * Floating UI instance with positioning and middleware.
      */
-    floating: UseFloatingReturn;
+    floating: UseFloatingReturn<Reference>;
     /**
      * Ref for the floating arrow element.
      */
@@ -145,5 +151,5 @@ interface UseHoneyPopupApi {
  *
  * @returns An object containing state and utilities for managing the popup.
  */
-export declare const useHoneyPopup: ({ enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, open, floatingOptions, offsetOptions, useFlip, flipOptions, useShift, shiftOptions, useArrow, arrowOptions, transitionOptions, useAutoPlacement, autoPlacementOptions, useAutoUpdate, autoUpdateOptions, useAutoSize, minAcceptableWidth, minAcceptableHeight, maxAcceptableWidth, maxAcceptableHeight, onOpen, onClose, }: UseHoneyPopupOptions) => UseHoneyPopupApi;
+export declare const useHoneyPopup: <Reference extends ReferenceType>({ enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, extraInteractions, open, floatingOptions, useOffset, offsetOptions, useFlip, flipOptions, useShift, shiftOptions, useArrow, arrowOptions, transitionOptions, useAutoPlacement, autoPlacementOptions, useAutoUpdate, autoUpdateOptions, useAutoSize, minAcceptableWidth, minAcceptableHeight, maxAcceptableWidth, maxAcceptableHeight, onOpen, onClose, }: UseHoneyPopupOptions<Reference>) => UseHoneyPopupApi<Reference>;
 export {};

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

@@ -1,2 +1,4 @@
+export * from './HoneyPopup.types';
+export * from './HoneyPopupContext';
 export * from './HoneyPopup';
 export * from './hooks';

package/dist/helpers/helpers.d.ts

@@ -1,9 +1,22 @@
 import { HTMLAttributes } from 'react';
-import { FastOmit, HoneyCSSDimensionUnit, HoneyFontName, HoneyColor, HoneyCSSColor, HoneyStyledContext, HoneyStyledFunction, HoneyDimensionName, HoneyBreakpointName, HoneyBreakpoints, HoneySpacings, HoneyCSSDimensionValue } from '@react-hive/honey-style';
-import { Nullable, HoneyScreenState, HoneyCSSShorthandTuple, HoneyCSSShorthandDimensionOutput, HoneyCSSSpacingValue, HoneyCSSMediaRule, HoneyPrefixedCSSProperties } from '../types';
+import { FastOmit, HoneyFontName, HoneyColor, HoneyCSSColor, HoneyStyledContext, HoneyStyledFunction, HoneyDimensionName, HoneyBreakpointName, HoneyBreakpoints, HoneySpacings, HoneyCSSDimensionUnit, HoneyCSSDimensionValue, HoneyCSSMediaRule } from '@react-hive/honey-style';
+import { Nullable, HoneyScreenState, HoneyCSSShorthandTuple, HoneyCSSShorthandDimensionOutput, HoneyCSSSpacingValue, HoneyPrefixedCSSProperties } from '../types';
 export declare const noop: () => void;
 export declare function assert(condition: any, message: string): asserts condition;
 export declare const generateUniqueId: () => string;
+/**
+ * Invokes the given input if it is a function, passing the provided arguments.
+ * Otherwise, returns the input as-is.
+ *
+ * @template Args - Tuple of argument types to pass to the function.
+ * @template Result - Return type of the function or the value.
+ *
+ * @param input - A function to invoke with `args`, or a direct value of type `Result`.
+ * @param args - Arguments to pass if `input` is a function.
+ *
+ * @returns The result of invoking the function, or the original value if it's not a function.
+ */
+export declare const invokeIfFunction: <Args extends any[], Result>(input: ((...args: Args) => Result) | Result, ...args: Args) => Result;
 /**
  * Determines the resolved type for spacing values when processed by `resolveSpacing`.
  *