@react-hive/honey-layout 4.1.0 → 5.2.0-beta

package/dist/components/HoneyBox.d.ts

@@ -5,4 +5,6 @@ export interface HoneyBoxProps extends HoneyPrefixedCSSProperties {
     as?: StyledTarget<'web'>;
     effects?: HoneyEffectResultFn<object>[];
 }
-export declare const HoneyBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, HTMLAttributes<HTMLDivElement> & HoneyBoxProps>> & string;
+type HoneyBoxInnerProps = HTMLAttributes<HTMLDivElement> & HoneyBoxProps;
+export declare const HoneyBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, HoneyBoxInnerProps>> & string;
+export {};

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

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { HoneyPopupProps, HoneyPopupChildrenContextProps } from '../HoneyPopup';
+import { HoneyContextMenuOption } from './HoneyContextMenu.types';
+import { HoneyContextMenuContentProps } from './HoneyContextMenuContent';
+export interface HoneyContextMenuProps<Option extends HoneyContextMenuOption<Context>, Context = undefined> extends Pick<HoneyPopupProps<Context>, 'context'>, HoneyContextMenuContentProps<Option, Context> {
+    children: (context: HoneyPopupChildrenContextProps) => ReactNode;
+}
+export declare const HoneyContextMenu: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ children, options, optionProps, context, }: HoneyContextMenuProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+interface HoneyContextMenuOptionExecutionContext<Context> {
+    context: Context | undefined;
+}
+export interface HoneyContextMenuOption<Context = undefined> {
+    id: string;
+    label: string;
+    options?: HoneyContextMenuOption<Context>[];
+    isVisible?: boolean | ((executionContext: HoneyContextMenuOptionExecutionContext<Context>) => boolean);
+    onClick?: (executionContext: HoneyContextMenuOptionExecutionContext<Context>) => void;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { HoneyContextMenuOption } from './HoneyContextMenu.types';
+import { HoneyContextMenuContentOptionProps } from './HoneyContextMenuContentOption';
+export interface HoneyContextMenuContentProps<Option extends HoneyContextMenuOption<Context>, Context> {
+    options: Option[] | undefined;
+    optionProps?: Omit<HoneyContextMenuContentOptionProps<Option, Context>, 'option'>;
+}
+export declare const HoneyContextMenuContent: <Option extends HoneyContextMenuOption<Context>, Context = undefined>({ options, optionProps, }: HoneyContextMenuContentProps<Option, Context>) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,2 @@
+export * from './HoneyContextMenu.types';
+export * from './HoneyContextMenu';

package/dist/components/HoneyFlexBox.d.ts

@@ -1,5 +1,3 @@
-export declare const HoneyFlexBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('./HoneyBox').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('./HoneyBox').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('./HoneyBox').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('./HoneyBox').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}>, never>, never>> & string;
+import { HoneyBoxProps } from './HoneyBox';
+export type HoneyFlexBoxProps = HoneyBoxProps;
+export declare const HoneyFlexBox: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, HoneyBoxProps>> & string;

package/dist/components/HoneyGrid/HoneyGrid.d.ts

@@ -1,14 +1,6 @@
 import { default as React } from 'react';
-import { HoneyBreakpointName } from '../../types';
 import { HoneyGridStyledProps } from './HoneyGridStyled';
 import { HoneyGridColumnStyledProps } from '../HoneyGridColumn';
-type HoneyGridContextValue = {
-    columns: number;
-    spacing: number | undefined;
-    isColumnGrowing: boolean;
-    applyColumnMaxWidth: HoneyBreakpointName | false;
-};
-export declare const HoneyGridContext: React.Context<HoneyGridContextValue | undefined>;
 export interface HoneyGridProps extends HoneyGridStyledProps {
     /**
      * The number of columns in the grid layout.
@@ -31,4 +23,3 @@ export interface HoneyGridProps extends HoneyGridStyledProps {
 export declare const HoneyGrid: React.ForwardRefExoticComponent<HoneyGridProps & {
     children?: React.ReactNode | undefined;
 } & React.RefAttributes<HTMLDivElement>>;
-export {};

package/dist/components/HoneyGrid/HoneyGridContext.d.ts

@@ -0,0 +1,8 @@
+import { HoneyBreakpointName } from '../../types';
+export interface HoneyGridContextProps {
+    columns: number;
+    spacing: number | undefined;
+    isColumnGrowing: boolean;
+    applyColumnMaxWidth: HoneyBreakpointName | false;
+}
+export declare const HoneyGridContext: import('react').Context<HoneyGridContextProps | undefined>;

package/dist/components/HoneyGrid/HoneyGridStyled.d.ts

@@ -17,8 +17,4 @@ export interface HoneyGridStyledProps extends HTMLAttributes<HTMLDivElement>, Om
      */
     spacing?: number;
 }
-export declare const HoneyGridStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}>, never>, HoneyGridStyledProps>> & string;
+export declare const HoneyGridStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, HoneyGridStyledProps>> & string;

package/dist/components/HoneyGrid/hooks/index.d.ts

@@ -1 +1 @@
-export * from './use-current-honey-grid';
+export * from './use-honey-grid-context';

package/dist/components/HoneyGrid/hooks/use-honey-grid-context.d.ts

@@ -0,0 +1 @@
+export declare const useHoneyGridContext: () => import('../HoneyGridContext').HoneyGridContextProps;

package/dist/components/HoneyGridColumn/HoneyGridColumnStyled.d.ts

@@ -29,8 +29,4 @@ export interface HoneyGridColumnStyledProps extends HTMLAttributes<HTMLDivElemen
  * It provides flexibility in specifying the number of columns to take, the total number of columns in the grid,
  * and the spacing between columns.
  */
-export declare const HoneyGridColumnStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}>, never>, never>, HoneyGridColumnStyledProps>> & string;
+export declare const HoneyGridColumnStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & HoneyBoxProps>, never>, keyof HoneyBoxProps> & HoneyBoxProps, HoneyGridColumnStyledProps>> & string;

package/dist/components/HoneyLazyContent.d.ts

@@ -1,30 +1,29 @@
 import { PropsWithChildren } from 'react';
-interface HoneyLazyContentProps {
+export interface HoneyLazyContentProps {
     /**
      * Determines whether the content should be mounted or unmounted.
      */
-    isMount: boolean;
+    mount: boolean;
     /**
-     * The delay in milliseconds before unmounting the content when `isMount` is set to `false`.
+     * The delay in milliseconds before unmounting the content when `mount` is set to `false`.
      */
     unmountDelay: number;
     /**
-     * Determines whether the content should always remain mounted, regardless of the value of `isMount`.
+     * Determines whether the content should always remain mounted, regardless of the value of `mount`.
      * If `true`, the content will never be unmounted.
      *
      * @default false
      */
-    isAlwaysMounted?: boolean;
+    alwaysMounted?: boolean;
     /**
      * Determines whether the content should remain mounted after the mount.
      * If `true`, the content will not be unmounted after the time it's mounted.
      *
      * @default false
      */
-    isKeepAfterMount?: boolean;
+    keepAfterMount?: boolean;
 }
 /**
  * Component for lazy loading/unloading content based on a mount/unmount state.
  */
-export declare const HoneyLazyContent: ({ children, isMount, unmountDelay, isAlwaysMounted, isKeepAfterMount, }: PropsWithChildren<HoneyLazyContentProps>) => import('react').ReactNode;
-export {};
+export declare const HoneyLazyContent: ({ children, mount, unmountDelay, alwaysMounted, keepAfterMount, }: PropsWithChildren<HoneyLazyContentProps>) => import('react').ReactNode;

package/dist/components/HoneyList/HoneyList.d.ts

@@ -1,4 +1,4 @@
-import { HTMLAttributes, RefAttributes, default as React } from 'react';
+import { default as React, HTMLAttributes, RefAttributes } from 'react';
 import { HoneyListGenericProps, HoneyListItem } from './HoneyList.types';
 import { HoneyBoxProps } from '../HoneyBox';
 import { HoneyStatusContentProps } from '../HoneyStatusContent';

package/dist/components/HoneyList/HoneyListStyled.d.ts

@@ -1,9 +1 @@
-export declare const HoneyListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}>, never>, never>, import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}, Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
-}>, never>, never>>, never>, never>> & string;
+export declare const HoneyListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof import('react').HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & import('react').HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps>, never>, never>> & string;

package/dist/components/HoneyLoopingList/HoneyLoopingList.d.ts

@@ -2,9 +2,7 @@ import { default as React } from 'react';
 import { HoneyBoxProps } from '../HoneyBox';
 import { HoneyListItem, HoneyListGenericProps } from '../HoneyList';
 type HoneyLoopingListDirection = 'vertical' | 'horizontal';
-export declare const HoneyLoopingListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & React.HTMLAttributes<HTMLDivElement> & HoneyBoxProps, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
-}, never>> & string;
+export declare const HoneyLoopingListStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.HTMLAttributes<HTMLDivElement> | keyof HoneyBoxProps> & React.HTMLAttributes<HTMLDivElement> & HoneyBoxProps, never>> & string;
 export declare const HoneyLoopingListItemStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
 interface HoneyLoopingListProps<Item extends HoneyListItem> extends HoneyBoxProps, HoneyListGenericProps<Item> {
     activeItemIndex: number;

package/dist/components/HoneyOverlay.d.ts

@@ -1,7 +1,7 @@
-import { ReactNode, HTMLAttributes } from 'react';
+import { default as React, ReactNode, HTMLAttributes } from 'react';
 import { HoneyActiveOverlay, HoneyOverlayId, Nullable } from '../types';
-import { HoneyBoxProps } from './HoneyBox';
-interface OverlayContext {
+import { HoneyFlexBoxProps } from './HoneyFlexBox';
+export interface HoneyOverlayContext {
     /**
      * The current overlay instance, including methods and metadata for managing the overlay.
      */
@@ -11,16 +11,16 @@ interface OverlayContext {
      */
     deactivateOverlay: () => void;
 }
-export interface HoneyOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, HoneyBoxProps {
+export interface HoneyOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'>, HoneyFlexBoxProps {
     /**
      * The content of the overlay, either as static nodes or a function that receives the object
      * with the current overlay state and helper methods.
      */
-    children: ReactNode | ((overlayContext: OverlayContext) => ReactNode);
+    children: ReactNode | ((overlayContext: HoneyOverlayContext) => ReactNode);
     /**
      * Determines whether the overlay is currently active.
      */
-    isActive: boolean;
+    active: boolean;
     /**
      * An optional unique identifier for the overlay.
      */
@@ -41,5 +41,4 @@ export interface HoneyOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>,
  *
  * @param props - The properties used to configure the overlay.
  */
-export declare const HoneyOverlay: ({ children, isActive, overlayId, onDeactivate, ...props }: HoneyOverlayProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const HoneyOverlay: React.ForwardRefExoticComponent<HoneyOverlayProps & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,61 @@
+import { CSSProperties, ReactNode } from 'react';
+import { UseInteractionsReturn, FloatingArrowProps, FloatingFocusManagerProps, MiddlewareData } from '@floating-ui/react';
+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 = Omit<HoneyOverlayProps, 'children' | 'active' | 'onDeactivate'>;
+export interface HoneyPopupProps<Context = undefined> extends Omit<HoneyPopupStyledProps, 'children' | 'content'>, UseHoneyPopupOptions {
+    children: (context: HoneyPopupChildrenContextProps) => ReactNode;
+    /**
+     * Content inside the popup.
+     */
+    content: ReactNode | ((context: HoneyPopupContextProps<Context>) => ReactNode);
+    /**
+     * Additional props for the floating content.
+     */
+    contentProps?: InheritedHoneyOverlayProps;
+    /**
+     * Props for managing focus inside the popup.
+     *
+     * @see https://floating-ui.com/docs/floatingfocusmanager#props
+     */
+    focusManagerProps?: Omit<FloatingFocusManagerProps, 'children' | 'context'>;
+    /**
+     * Whether to show an arrow indicator.
+     *
+     * @default false
+     */
+    showArrow?: boolean;
+    /**
+     * Properties for an arrow component.
+     *
+     * @see https://floating-ui.com/docs/FloatingArrow#props
+     */
+    arrowProps?: Omit<FloatingArrowProps, 'ref' | 'context'>;
+    /**
+     * Properties for `HoneyPopupPortal` component.
+     */
+    portalProps?: Omit<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;
+}
+/**
+ * A popup component that provides floating behavior with customizable options.
+ *
+ * @template Context - Optional context type.
+ */
+export declare const HoneyPopup: <Context = undefined>({ children, content, contentProps, focusManagerProps, enabled, open, event, arrowOptions, floatingOptions, offsetOptions, shiftOptions, flipOptions, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, transitionOptions, showArrow, useAutoUpdate, autoUpdateOptions, arrowProps, portalProps, adjustStyles, context, onOpen, onClose, ...props }: HoneyPopupProps<Context>) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+export interface HoneyPopupContextProps<Context> {
+    context: Context | undefined;
+    closePopup: () => void;
+}
+export declare const HoneyPopupContext: import('react').Context<HoneyPopupContextProps<any> | undefined>;

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { FloatingPortalProps } from '@floating-ui/react';
+/**
+ * @see https://floating-ui.com/docs/floatingportal#props
+ */
+export interface HoneyPopupPortalProps extends FloatingPortalProps {
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+}
+export declare const HoneyPopupPortal: ({ children, enabled, ...props }: HoneyPopupPortalProps) => 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;

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

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from 'react';
+import { HoneyFlexBoxProps } from '../HoneyFlexBox';
+export interface HoneyPopupStyledProps extends HTMLAttributes<HTMLDivElement>, HoneyFlexBoxProps {
+}
+export declare const HoneyPopupStyled: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('styled-components').FastOmit<import('styled-components/dist/types').Substitute<import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps, import('styled-components').FastOmit<import('react').DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof HTMLAttributes<HTMLDivElement> | keyof import('..').HoneyBoxProps> & HTMLAttributes<HTMLDivElement> & import('..').HoneyBoxProps>, never>, keyof import('..').HoneyBoxProps> & import('..').HoneyBoxProps>, never>, HoneyPopupStyledProps>> & string;

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

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+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;

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

@@ -0,0 +1,2 @@
+export * from './use-honey-popup';
+export * from './use-honey-popup-context';

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

@@ -0,0 +1 @@
+export declare const useHoneyPopupContext: () => import('../HoneyPopupContext').HoneyPopupContextProps<any>;

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

@@ -0,0 +1,55 @@
+import { FloatingContext, UseDismissProps, UseClickProps, UseHoverProps, UseFocusProps, UseClientPointProps, UseRoleProps } from '@floating-ui/react';
+/**
+ * Options for configuring popup interactions.
+ */
+export interface UseHoneyPopupInteractionsOptions {
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Determines the trigger event for opening the popup.
+     *
+     * @default 'click'
+     */
+    event?: 'click' | 'hover' | 'focus' | 'point' | 'manual';
+    /**
+     * Configuration for dismiss behavior.
+     *
+     * @see https://floating-ui.com/docs/usedismiss
+     */
+    dismissOptions?: Omit<UseDismissProps, 'enabled' | 'escapeKey'>;
+    /**
+     * Configuration for click interactions.
+     *
+     * @see https://floating-ui.com/docs/useclick
+     */
+    clickOptions?: Omit<UseClickProps, 'enabled'>;
+    /**
+     * Configuration for hover interactions.
+     *
+     * @prop restMs Default is 150.
+     *
+     * @see https://floating-ui.com/docs/usehover
+     */
+    hoverOptions?: Omit<UseHoverProps, 'enabled'>;
+    /**
+     * Configuration for focus interactions.
+     *
+     * @see https://floating-ui.com/docs/usefocus
+     */
+    focusOptions?: Omit<UseFocusProps, 'enabled'>;
+    /**
+     * Configuration for pointer interactions.
+     *
+     * @see https://floating-ui.com/docs/useclientpoint
+     */
+    clientPointsOptions?: Omit<UseClientPointProps, 'enabled'>;
+    /**
+     * Configuration for role assignment.
+     *
+     * @see https://floating-ui.com/docs/userole
+     */
+    roleOptions?: Omit<UseRoleProps, 'enabled'>;
+}
+export declare const useHoneyPopupInteractions: (context: FloatingContext, { enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, }: UseHoneyPopupInteractionsOptions) => import('@floating-ui/react').UseInteractionsReturn;

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

@@ -0,0 +1,96 @@
+import { useTransitionStyles, AutoUpdateOptions, ArrowOptions, FlipOptions, OffsetOptions, ShiftOptions, UseFloatingOptions, UseFloatingReturn, UseInteractionsReturn, UseTransitionStylesProps } from '@floating-ui/react';
+import { RefObject } from 'react';
+import { Nullable } from '../../../types';
+import { UseHoneyPopupInteractionsOptions } from './use-honey-popup-interactions';
+export interface UseHoneyPopupOptions extends UseHoneyPopupInteractionsOptions {
+    open?: boolean;
+    /**
+     * Configuration for the floating arrow.
+     */
+    arrowOptions?: Omit<ArrowOptions, 'element'>;
+    /**
+     * Options for configuring the floating UI behavior.
+     */
+    floatingOptions?: Omit<UseFloatingOptions, 'nodeId' | 'open' | 'whileElementsMounted' | 'onOpenChange'>;
+    /**
+     * Configuration for offset middleware.
+     *
+     * @see https://floating-ui.com/docs/offset
+     */
+    offsetOptions?: OffsetOptions;
+    /**
+     * Configuration for flip middleware.
+     *
+     * @prop crossAxis - Default is `false`.
+     *  See details by https://floating-ui.com/docs/flip#combining-with-shift
+     */
+    flipOptions?: FlipOptions;
+    /**
+     * Configuration for shift middleware.
+     *
+     * @see https://floating-ui.com/docs/shift
+     */
+    shiftOptions?: ShiftOptions;
+    /**
+     * @prop duration Default is 250.
+     *
+     * @see https://floating-ui.com/docs/usetransition#usetransitionstyles
+     */
+    transitionOptions?: UseTransitionStylesProps;
+    /**
+     * Whether to use automatic position updates.
+     *
+     * @default false
+     */
+    useAutoUpdate?: boolean;
+    /**
+     * Configuration for auto-update behavior.
+     *
+     * @see https://floating-ui.com/docs/autoupdate
+     */
+    autoUpdateOptions?: AutoUpdateOptions;
+    /**
+     * Callback invoked when the popup opens.
+     */
+    onOpen?: () => void;
+    /**
+     * Callback invoked when the popup closes.
+     */
+    onClose?: () => void;
+}
+interface UseHoneyPopupApi {
+    /**
+     * Unique identifier for the floating element.
+     */
+    nodeId: string | undefined;
+    /**
+     * Whether the popup is currently open.
+     */
+    isOpen: boolean;
+    /**
+     * Floating UI instance with positioning and middleware.
+     */
+    floating: UseFloatingReturn;
+    /**
+     * Ref for the floating arrow element.
+     */
+    arrowRef: RefObject<Nullable<SVGSVGElement>>;
+    /**
+     * Event handlers for the popup (click, hover, etc.).
+     */
+    interactions: UseInteractionsReturn;
+    transition: ReturnType<typeof useTransitionStyles>;
+    /**
+     * Function to manually close the popup.
+     */
+    closePopup: () => void;
+}
+/**
+ * Hook for managing a floating popup with customizable behavior.
+ *
+ * @param options - Configuration options for the popup.
+ *
+ * @returns An object containing state and utilities for managing the popup.
+ */
+export declare const useHoneyPopup: ({ enabled, event, dismissOptions, clickOptions, hoverOptions, focusOptions, clientPointsOptions, roleOptions, open, arrowOptions, floatingOptions, offsetOptions, flipOptions, shiftOptions, transitionOptions, useAutoUpdate, autoUpdateOptions, onOpen, onClose, }: UseHoneyPopupOptions) => UseHoneyPopupApi;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './HoneyPopup';
+export * from './hooks';

package/dist/components/HoneyStatusContent.d.ts

@@ -50,4 +50,4 @@ export interface HoneyStatusContentProps {
 /**
  * A component that conditionally renders blocks based on specified boolean flags.
  */
-export declare const HoneyStatusContent: ({ children, isLoading, isLoadingOverContent, isError, isNoContent, loadingContent, errorContent, noContent, }: PropsWithChildren<HoneyStatusContentProps>) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null;
+export declare const HoneyStatusContent: ({ children, isLoading, isLoadingOverContent, isError, isNoContent, loadingContent, errorContent, noContent, }: PropsWithChildren<HoneyStatusContentProps>) => 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;

package/dist/components/index.d.ts

@@ -7,3 +7,5 @@ export * from './HoneyLoopingList';
 export * from './HoneyStatusContent';
 export * from './HoneyLazyContent';
 export * from './HoneyOverlay';
+export * from './HoneyPopup';
+export * from './HoneyContextMenu';

package/dist/contexts/HoneyLayoutContext.d.ts

@@ -42,7 +42,7 @@ export interface HoneyLayoutContextValue {
      * @param [unit] - The CSS unit to use for the calculated value. Defaults to 'px'.
      * @param [type] - The type of spacing to use from the theme (e.g., 'base', 'small', 'large').
      *
-     * @returns {ResolveSpacingResult<MultiValue, Unit>} - The resolved spacing value, formatted as a string with the appropriate unit.
+     * @returns The resolved spacing value, formatted as a string with the appropriate unit.
      */
     resolveSpacing: <MultiValue extends HoneyCSSMultiValue<number>, Unit extends Nullable<HoneyCSSDimensionUnit> = 'px'>(value: MultiValue, unit?: Unit, type?: keyof HoneySpacings) => ResolveSpacingResult<MultiValue, Unit>;
     /**

package/dist/effects.d.ts

@@ -37,7 +37,7 @@ export interface HoneyVisibilityTransitionEffectContextProps {
      *
      * @default false
      */
-    isActive?: boolean;
+    active?: boolean;
 }
 /**
  * A styled-components effect that applies smooth transitions to the `visibility`, `opacity`, and optional extra properties of an element.

package/dist/helpers/helpers.d.ts

@@ -1,6 +1,7 @@
 import { HTMLAttributes } from 'react';
 import { ExecutionContext, StyleFunction, css } from 'styled-components';
 import { Nullable, HoneyBreakpointName, HoneyCSSArrayValue, HoneyCSSDimensionShortHandValue, HoneyCSSDimensionUnit, HoneyCSSMultiValue, HoneyCSSMediaRule, HoneySpacings, HoneyColorKey, HoneyFontName, HoneyCSSColor, HoneyDimensionName, HoneyPrefixedCSSProperties, HoneyBreakpoints, HoneyScreenState, HoneyCSSDimensionValue } from '../types';
+export declare const noop: () => void;
 export declare function assert(condition: any, message: string): asserts condition;
 export declare const generateUniqueId: () => string;
 /**

package/dist/helpers/react.helpers.d.ts

@@ -1,2 +1,12 @@
+import { Ref, RefCallback } from 'react';
 import { IStyleSheetManager } from 'styled-components';
 export declare const shouldForwardProp: IStyleSheetManager['shouldForwardProp'];
+/**
+ * Merges multiple refs into a single ref callback.
+ * This ensures that all provided refs receive the same reference.
+ *
+ * @param refs - A list of refs that need to be merged.
+ *
+ * @returns A single ref callback that assigns the element to all provided refs.
+ */
+export declare const mergeRefs: <T>(...refs: (Ref<T> | undefined)[]) => RefCallback<T>;