@react-fabric/core 1.0.0-beta.6 → 1.0.0-beta.60

package/dist/types/core/aside/Aside.d.ts

@@ -1,14 +1,18 @@
-import { type ReactNode } from "react";
-import { type ChildrenProp, type CollapseProps, type CssProp, type Elements, type IconProps, type TestProps } from "../../types";
-export interface AsideProps extends IconProps, ChildrenProp, CollapseProps, CssProp, TestProps {
+import { type IconProps } from "../../components/icon/Icon";
+import { type ChildrenProp, type CollapseProps, type CssProp, type Elements, type TestProps } from "../../types";
+export interface AsideProps extends ChildrenProp, CollapseProps, CssProp, TestProps {
     /**
      * page title
      */
-    title?: ReactNode;
+    title?: React.ReactNode;
     /**
      * align inline-end
      */
     align?: "start" | "end";
+    /**
+     * icon path or props
+     */
+    icon?: IconProps;
     /**
      * header actions
      */
@@ -51,6 +55,41 @@ export interface AsideProps extends IconProps, ChildrenProp, CollapseProps, CssP
     minWidth?: number | string;
 }
 /**
- * Side panel
+ * A sidebar component that can be collapsed, resized, and has a flyout feature.
+ * It supports a title, icon, actions, and loading state.
+ * It can be aligned to the start or end of the page.
+ *
+ * @param {AsideProps} props - The properties for the Aside component.
+ * @returns {JSX.Element} The rendered Aside component.
+ *
+ * @example
+ * ```jsx
+ * <Aside
+ *   title="Sidebar Title"
+ *   icon={CoreIcons.menu}
+ *   rtlFlip={true}
+ *   className="custom-aside"
+ *   bodyClassName="custom-aside-body"
+ *   headerClassName="custom-aside-header"
+ *   resizeable={true}
+ *   flyout={true}
+ *   onFlyout={() => console.log("Flyout triggered")}
+ *   collapsed={false}
+ *   collapsable={true}
+ *   onCollapse={() => console.log("Collapsed toggled")}
+ *   actions={<button>Action</button>}
+ *   loading={false}
+ *   align="start"
+ *   width="20rem"
+ *   minWidth="2rem"
+ *   maxWidth="30vw"
+ *   data-testid="aside-test"
+ *   data-test-value="aside-value"
+ * >
+ *   <Content>This is the content of the aside.</Content>
+ * </Aside>
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--aside} for more details.
  */
-export declare const Aside: ({ children, title, icon, iconBg, iconColor, rtlFlip, className, bodyClassName, headerClassName, resizeable, flyout, onFlyout, collapsed, collapsable, onCollapse, actions, loading, align, width: wd, minWidth, maxWidth, "data-testid": testId, "data-test-value": testValue, }: AsideProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Aside: ({ children, title, icon, className, bodyClassName, headerClassName, resizeable, flyout, onFlyout, collapsed, collapsable, onCollapse, actions, loading, align, width: wd, minWidth, maxWidth, "data-testid": testId, "data-test-value": testValue, }: AsideProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/boundary/ErrorBoundary.d.ts

@@ -1,7 +1,23 @@
 import { Component } from "react";
 import { type ChildrenProp } from "../../types";
 /**
- * An error boundary wrapper higher-order component designed to provide consistent error display across the application will trap runtime errors
+ * ErrorBoundary component to catch JavaScript errors anywhere in the child component tree,
+ * log those errors, and display a fallback UI.
+ * It can also display a custom error element if provided.
+ * This component is useful for preventing the entire application from crashing
+ * when an error occurs in a part of the component tree.
+ * It can be used to wrap any part of the application.
+ * It supports custom error display components and provides a default error message.
+ * It also conditionally displays the error stack trace in development mode.
+ *
+ * @example
+ * ```jsx
+ * <ErrorBoundary errorElement={CustomErrorComponent}>
+ *   <YourComponent />
+ * </ErrorBoundary>
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--error-boundary}
  */
 export declare class ErrorBoundary extends Component<{
     /**
@@ -22,5 +38,5 @@ export declare class ErrorBoundary extends Component<{
     };
     constructor(props: AnyObject);
     componentDidCatch(error: Error): void;
-    render(): string | number | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
 }

package/dist/types/core/content/Content.d.ts

@@ -11,6 +11,11 @@ export interface ContentProps extends ChildrenProp, CssProp, RefProp, TestProps
     onResize?: (event: SizeObject) => void;
 }
 /**
- * Scrollable content element
+ * Content component that wraps children in a section element.
+ * It uses a resize observer to handle resizing and a debounced scroll handler.
+ * It also includes an error boundary to catch any errors in the children.
+ *
+ * @param {ContentProps} props - The properties for the Content component.
+ * @returns A section element containing the children wrapped in an error boundary.
  */
 export declare const Content: ({ ref, children, className, onScroll, onResize, "data-testid": testId, "data-test-value": testValue, }: ContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/headfoot/HeadFoot.d.ts

@@ -1,14 +1,6 @@
-import { type AriaProps, type ChildrenProp, type ColorWithGrays, type CssProp, type TestProps } from "../../types";
+import { type AriaProps, type ChildrenProp, type CssProp, type TestProps } from "../../types";
 interface BaseProps extends CssProp, AriaProps, ChildrenProp, TestProps {
     dir?: "ltr" | "rtl";
-    /**
-     * background color
-     */
-    bg?: ColorWithGrays | string;
-    /**
-     * background color
-     */
-    color?: ColorWithGrays | string;
 }
 type DefaultProps = BaseProps & {
     flex?: false;
@@ -19,6 +11,46 @@ type FlexProps = BaseProps & {
     justify?: "start" | "end" | "center" | "between";
 };
 export type HeadFootProps = DefaultProps | FlexProps;
+/**
+ * Header component that wraps children in a header element.
+ * It uses the HeadFoot component to handle layout and styling.
+ * It accepts properties for direction, alignment, and justification,
+ * allowing for flexible layout configurations.
+ * The `as` prop is set to "header" to render the element as a header.
+ * The `area` prop is set to "head" to indicate that this is a header area.
+ * It can be used to create a consistent header layout across an application.
+ *
+ * @param {HeadFootProps} props - The properties for the Header component.
+ * @returns A header element containing the children wrapped in the HeadFoot component.
+ *
+ * @example
+ * ```jsx
+ * <Header className="custom-header" dir="ltr">
+ *   <h1>Header content goes here</h1>
+ * </Header>
+ * ```
+ */
 export declare const Header: (props: HeadFootProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Footer component that wraps children in a footer element.
+ * It uses the HeadFoot component to handle layout and styling.
+ * It accepts properties for direction, alignment, and justification,
+ * allowing for flexible layout configurations.
+ * The `as` prop is set to "footer" to render the element as a footer.
+ * The `area` prop is set to "foot" to indicate that this is a footer area.
+ * It can be used to create a consistent footer layout across an application.
+ * * The Footer component is designed to be flexible and can be styled with custom classes.
+ * It supports both default and flex layouts, allowing for alignment and justification of its children.
+ *
+ * @param {HeadFootProps} props - The properties for the Footer component.
+ * @returns A footer element containing the children wrapped in the HeadFoot component.
+ *
+ * @example
+ * ```jsx
+ * <Footer className="custom-footer" dir="ltr">
+ *   <p>Footer content goes here</p>
+ * </Footer>
+ * ```
+ */
 export declare const Footer: (props: HeadFootProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/core/page/Page.d.ts

@@ -1,5 +1,6 @@
-import { type ChildrenProp, type IconProps, type TestProps } from "../../types";
-export interface PageProps extends IconProps, ChildrenProp, TestProps {
+import { type IconProps } from "../../components/icon/Icon";
+import { type ChildrenProp, type RefProp, type TestProps } from "../../types";
+export interface PageProps extends ChildrenProp, TestProps, RefProp<HTMLDivElement> {
     /**
      * page title
      */
@@ -12,12 +13,39 @@ export interface PageProps extends IconProps, ChildrenProp, TestProps {
      * paper style drop shadow
      */
     paper?: boolean;
+    /**
+     * icon path or props
+     */
+    icon?: IconProps;
     /**
      * loading indicator
      */
     loading?: boolean;
 }
 /**
- * The page component used typically for routes, is a structured layout used within an application to organize and display content in a sectioned format, ensuring a consistent and intuitive user experience.
+ * Page component that wraps children in a div element.
+ * It includes a title section with an optional icon and a loading indicator.
+ * The component can be styled with a paper effect, page icon and title.
+ * It also accepts a loading prop to display a loading indicator.
+ *
+ * @param {PageProps} props - The properties for the Page component.
+ * @returns A div element containing the title and children, with optional loading indicator.
+ *
+ * @example
+ * ```jsx
+ * <Page
+ *   title="My Page"
+ *   icon="home"
+ *   loading={false}
+ *   paper={true}
+ *   data-testid="my-page"
+ *   data-test-value="page-value"
+ * >
+ *   <p>This is the content of the page.</p>
+ * </Page>
+ * // Renders a page with a title, icon, and content.
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--page} for more details.
  */
-export declare const Page: ({ children, paper, title, titleClassName, icon, rtlFlip, iconBg, iconColor, loading, "data-testid": testId, "data-test-value": testValue, }: PageProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Page: ({ ref, children, paper, title, titleClassName, icon, loading, "data-testid": testId, "data-test-value": testValue, ...rest }: PageProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/responsive/Responsive.d.ts

@@ -39,15 +39,70 @@ export interface ColProps extends AriaProps, CssProp, TestProps, Partial<Childre
     /**
      * column flex
      */
-    flex?: "auto" | "fill" | "full";
+    flex?: "auto" | "fill" | "full" | "initial" | "content";
     /**
      * stretch inner content
      */
     stretchContent?: boolean;
+    /**
+     * truncate text
+     */
+    truncate?: boolean;
 }
 /**
- * Responsive layout container
+ * Container component that wraps children in a div element.
+ * It supports full width, gutter size, and additional CSS classes.
+ * It can be used to create a responsive layout with optional gutters for spacing.
+ * It accepts properties for full width, gutter size, and additional CSS classes.
+ *
+ * @param {ContainerProps} props - The properties for the Container component.
+ * @returns A div element containing the children with optional full width and gutter size.
+ *
+ * @example
+ * ```jsx
+ * <Container fullWidth={true} gutter="16px" className="custom-container">
+ *   <p>This is a container with full width and gutter.</p>
+ * </Container>
+ * ```
  */
 export declare const Container: ({ children, fullWidth, className, gutter, ...aria }: ContainerProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Row component that allows for flexible layout of columns.
+ * It supports various flex properties, alignment, and wrapping.
+ * It can be used to create a responsive layout with optional gutters for spacing.
+ * It accepts properties for gutter size, orientation, alignment, justification, and additional CSS classes.
+ *
+ * @param {RowProps} props - The properties for the Row component.
+ * @returns A div element representing a row with the specified flex and alignment properties.
+ *
+ * @example
+ * ```jsx
+ * <Row gutter="16px" orient="row" align="center" justify="between">
+ *   <Col flex="fill">Column 1</Col>
+ *   <Col flex="fill">Column 2</Col>
+ * </Row>
+ * // Renders a row with two columns, each taking equal space, centered vertically and spaced evenly.
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--responsive} for more details.
+ */
 export declare const Row: ({ children, gutter, noWrap, orient, align, justify, className, ...aria }: RowProps) => import("react/jsx-runtime").JSX.Element;
-export declare const Col: ({ children, flex, align, className, stretchContent, ...aria }: ColProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Column component that allows for flexible layout within a row.
+ * It supports various flex properties, alignment, and truncation.
+ * It can be used to create a responsive layout with optional stretching of inner content.
+ * It accepts properties for flex size, alignment, truncation, and additional CSS classes.
+ *
+ * @param {ColProps} props - The properties for the Col component.
+ * @returns A div element representing a column with the specified flex and alignment properties.
+ *
+ * @example
+ * ```jsx
+ * <Col flex="fill" align="center" truncate className="custom-col">
+ *   <p>This is a column with flexible layout.</p>
+ * </Col>
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--responsive} for more details.
+ */
+export declare const Col: ({ children, flex, align, truncate, className, stretchContent, ...aria }: ColProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/section/Section.d.ts

@@ -1,7 +1,22 @@
-import { type ChildrenProp, type CssProp, type RefProp } from "../../types";
+import { type TestProps, type ChildrenProp, type CssProp, type RefProp } from "../../types";
 /**
- * The section component provides a structured layout used within a page to organize and display content in a sectioned format, ensuring a consistent and intuitive user experience.
+ * A component that represents a section of content within a page, with templated grid layout.
+ * It can be used to group related content together and can be styled with additional CSS classes.
+ * It supports RTL (right-to-left) text direction.
+ *
+ * @param {ChildrenProp} children - The children to be rendered inside the section.
+ * @param {CssProp} className - Additional CSS classes to apply to the section.
+ * @param {RefProp<HTMLDivElement>} ref - A ref to the section element.
+ *
+ * @example
+ * ```jsx
+ * <Section className="my-section" ref={sectionRef}>
+ *   <p>This is a section.</p>
+ * </Section>
+ * ```
+ *
+ *  @see {@link https://adarshpastakia.github.io/react-fabric/?path=/docs/core-application--section} for more details.
  */
-export declare const Section: ({ children, className, dir, ref, }: ChildrenProp & CssProp & RefProp<HTMLDivElement> & {
+export declare const Section: ({ children, className, dir, ref, ...rest }: ChildrenProp & CssProp & TestProps & RefProp<HTMLDivElement> & {
     dir?: "ltr" | "rtl";
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/theme/ThemeProvider.d.ts

@@ -8,9 +8,9 @@ export interface ThemeProps {
      * branding css className
      *
      * .branding {
-     *  --primary: #color;
-     *  --accent: #color;
-     *  --tint: #color;
+     *  --color-primary: #color;
+     *  --color-accent: #color;
+     *  --color-tint: #color;
      * }
      */
     branding?: string;
@@ -29,9 +29,29 @@ export interface ThemeProps {
     /**
      * component rounding
      */
-    rounding?: "minimal" | "normal" | "full";
+    rounding?: "sm" | "md" | "full";
 }
 /**
- * Theme override
+ * This component provides a way to set the theme for the application.
+ * It allows you to set the primary, accent, and tint colors, as well as the color scheme and rounding.
+ * It uses CSS variables to apply the colors and styles.
+ * It also applies the branding className to the root element.
+ * The component uses the `useApplicationContext` hook to get the current color scheme from the application context.
+ *
+ * @example
+ * ```jsx
+ * <ThemeProvider
+ *   branding="my-branding"
+ *   primaryColor="#ff0000"
+ *   accentColor="#00ff00"
+ *   tintColor="#0000ff"
+ *   colorScheme="dark"
+ *   rounding="md"
+ * >
+ *   <div>Your content here</div>
+ * </ThemeProvider>
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/story/core-application--theme-provider} for more details.
  */
 export declare const ThemeProvider: ({ children, branding, primaryColor, accentColor, tintColor, colorScheme, rounding, }: ThemeProps & ChildrenProp) => import("react/jsx-runtime").JSX.Element;

package/dist/types/core/viewport/Viewport.d.ts

@@ -1,5 +1,19 @@
 import { type PropsWithChildren } from "react";
 /**
- * The application viewport is the main container that defines the visible area where content is displayed and interacted with.
+ * This component is used to create a full-screen viewport
+ * that can be used to display content in a grid layout.
+ * It is typically used as a container for the main content of the application.
+ * It is styled to take up the full width and height of the viewport,
+ * and it uses absolute positioning to ensure it covers the entire screen.
+ * The component accepts children as props, allowing you to nest other components inside it.
+ *
+ * @example
+ * ```jsx
+ * <Viewport>
+ *   <YourContentComponent />
+ * </Viewport>
+ * ```
+ *
+ * @see {@link https://adarshpastakia.github.io/react-fabric/?path=/docs/core-application--viewport} for more details.
  */
 export declare const Viewport: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;

package/dist/types/hooks/useControlledValue.d.ts

@@ -1,5 +1,16 @@
-/// <reference types="react" />
-export declare const useControlledValue: <T extends unknown = string>(value: T, defaultValue: T) => {
+/**
+ * Custom hook to manage a controlled value with a default fallback for inputs.
+ * It updates the current value whenever the deferred value changes.
+ * This is useful for scenarios where you want to control the value of a component
+ * while also providing a default value if the controlled value is not set.
+ * This hook is particularly useful for form inputs or components that require a controlled value
+ * but also need to handle cases where the value might not be immediately available.
+ *
+ * @param value - The controlled value that may change.
+ * @param defaultValue - The default value to use if the controlled value is not set.
+ * @returns An object containing the current value and a function to update it.
+ */
+export declare const useControlledValue: <T extends AnyObject = string>(value: T, defaultValue: T) => {
     currentValue: T;
     updateValue: import("react").Dispatch<import("react").SetStateAction<T>>;
 };

package/dist/types/hooks/useDebounce.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Custom hook to debounce a function.
+ * This hook delays the processing of the function until after a specified delay period
+ * has elapsed since the last time the function was invoked. This is useful for optimizing
+ * performance in scenarios where a function may be called frequently, such as during
+ * user input or window resizing events.
+ *
+ * @param callback - The function to debounce.
+ * @param deps - The dependency array for the hook.
+ * @param delay - The debounce delay in milliseconds.
+ * @returns A debounced version of the callback function.
+ */
 export declare const useDebounce: (callback: undefined | ((...rest: AnyObject) => AnyObject), deps: AnyObject[], delay?: number) => {
     (...args: AnyObject): void;
     cancel(): void;

package/dist/types/hooks/useEffectDebugger.d.ts

@@ -1,4 +1,53 @@
 import { type DependencyList, type EffectCallback } from "react";
+/**
+ * Custom hook to debug useMemo hooks.
+ * It compares the current and previous dependency arrays and logs any differences.
+ * @param func - The function to be memoized or executed in the effect.
+ * @param inputs - The dependency array for the hook.
+ * @param prefix - A prefix for the log messages to identify the hook.
+ * @returns The result of the memoized function or the effect.
+ *
+ * @example
+ * ```jsx
+ * const value = useMemoDebugger(() => computeValue(), [dependency1, dependency2], "MyComponent");
+ * ```
+ */
 export declare const useMemoDebugger: <T>(func: () => T, inputs: DependencyList, prefix: string) => T;
+/**
+ * Custom hook to debug useEffect and useLayoutEffect hooks.
+ * It compares the current and previous dependency arrays and logs any differences.
+ * @param func - The effect function to be executed.
+ * @param inputs - The dependency array for the effect.
+ * @param prefix - A prefix for the log messages to identify the effect.
+ * @returns A cleanup function if the effect returns one.
+ *
+ * @example
+ * ```jsx
+ * useEffectDebugger(() => {
+ *   // Effect logic here
+ *   return () => {
+ *     // Cleanup logic here
+ *   };
+ * }, [dependency1, dependency2], "MyComponent");
+ * ```
+ */
 export declare const useEffectDebugger: (func: EffectCallback, inputs: DependencyList, prefix: string) => void;
+/**
+ * Custom hook to debug useLayoutEffect hooks.
+ * It compares the current and previous dependency arrays and logs any differences.
+ * @param func - The layout effect function to be executed.
+ * @param inputs - The dependency array for the layout effect.
+ * @param prefix - A prefix for the log messages to identify the layout effect.
+ * @returns A cleanup function if the layout effect returns one.
+ *
+ * @example
+ * ```jsx
+ * useLayoutEffectDebugger(() => {
+ *   // Layout effect logic here
+ *   return () => {
+ *     // Cleanup logic here
+ *   };
+ * }, [dependency1, dependency2], "MyComponent");
+ * ```
+ */
 export declare const useLayoutEffectDebugger: (func: EffectCallback, inputs: DependencyList, prefix: string) => void;

package/dist/types/hooks/useIsDark.d.ts

@@ -1 +1,9 @@
+/**
+ * Custom hook to determine if the current theme is dark.
+ * It checks the background color of the document's root element
+ * and sets the `isDark` state based on the red component of the RGB color.
+ * If the red component is less than 50, it considers the theme to be dark.
+ *
+ * @returns {boolean} - Returns true if the theme is dark, false otherwise.
+ */
 export declare const useIsDark: () => boolean;

package/dist/types/hooks/useIsRtl.d.ts

@@ -1 +1,13 @@
+/**
+ * Custom hook to determine if the current locale is RTL (Right-to-Left).
+ * It uses the i18n instance from react-i18next to check the direction.
+ *
+ * @returns {boolean} - Returns true if the current locale is RTL, false otherwise.
+ *
+ * @example
+ * ```jsx
+ * const isRtl = useIsRtl();
+ * // This will return true if the current locale is RTL, false otherwise.
+ * ```
+ */
 export declare const useIsRtl: () => boolean;

package/dist/types/hooks/useNavigator.d.ts

@@ -1,4 +1,21 @@
-/// <reference types="react" />
+/**
+ * Custom hook to manage navigation through a list of items.
+ * It provides functionality to navigate forward and backward,
+ * and keeps track of the current index and total count of items.
+ *
+ * @param totalCount - Total number of items to navigate through.
+ * @param defaultIndex - Initial index to start navigation from.
+ * @returns An object containing the current index, a function to navigate,
+ *          a label for the current position, and a function to set the current index.
+ *
+ * @example
+ * ```jsx
+ * const { headLabel, onNavigate, currentIndex, setCurrentIndex } = useNavigator(5, 0);
+ * // headLabel will show "1/5"
+ * // onNavigate(1) will move to the next item, and onNavigate(-1) will move to the previous item.
+ * // currentIndex will be updated accordingly.
+ * ```
+ */
 export declare const useNavigator: (totalCount?: number, defaultIndex?: number) => {
     headLabel: import("react/jsx-runtime").JSX.Element;
     onNavigate: (dir: 1 | -1) => void;

package/dist/types/hooks/useOverlayService.d.ts

@@ -1,10 +1,29 @@
-import { type FC, type ReactNode } from "react";
-type OverlayComponent = FC<{
-    onClose: (args?: AnyObject) => void;
-    [key: string]: AnyObject;
-}>;
-export declare const useOverlayService: (ModalOrFlyout: OverlayComponent) => [
-    Overlay: ReactNode | null,
-    openOverlay: (props?: KeyValue) => Promise<AnyObject>
-];
+import { type ElementType } from "react";
+import { type ModalProps } from "../types";
+type OverlayComponent = ElementType<ModalProps<AnyObject>>;
+/**
+ * Hook to manage overlay components like modals or flyouts.
+ * It provides a way to open an overlay with specified properties and handle its closure.
+ * This hook returns the current overlay component and a function to open it with props.
+ * It is useful for scenarios where you need to display overlays dynamically,
+ * such as modals, flyouts, or any other overlay components in a React application.
+ * The `openOverlay` function returns a promise that resolves with the result
+ * of the overlay when it is closed, allowing you to handle the result in a controlled manner.
+ *
+ * @param ModalOrFlyout - The component to be used as an overlay.
+ * @returns An array containing the current overlay and a function to open it.
+ *
+ * @example
+ * ```jsx
+ * const [Overlay, openOverlay] = useOverlayService(MyModalComponent);
+ * // To open the overlay:
+ * const handleOpen = async () => {
+ *   const result = await openOverlay({ title: "My Modal", content: "Hello World" });
+ *   console.log(result); // Handle the result from the overlay
+ * };
+ * <button onClick={handleOpen}>Open Modal</button>
+ * <Overlay />
+ * ```
+ */
+export declare const useOverlayService: (ModalOrFlyout: OverlayComponent) => [Overlay: React.ReactNode | null, openOverlay: (props?: KeyValue) => Promise<AnyObject>];
 export {};

package/dist/types/hooks/usePropToggle.d.ts

@@ -1,9 +1,20 @@
 import { type RefObject } from "react";
 /**
- * hook to control boolean props
- * @param isOn (is prop true)
- * @param callback (optional callback)
- * @param key (optional key to pass to callback)
- * @returns
+ * This hook is used to manage a toggle state based on a prop value.
+ * It allows you to toggle the state and also provides a reference to the current state.
+ * It is useful for scenarios where you want to control a toggle state from a parent component while also allowing local toggling.
+ *
+ * @param isOn - Initial state of the toggle (default: false)
+ * @param onToggle - Callback function that is called when the toggle state changes.
+ * @param key - Optional key to identify the toggle state, useful for multiple toggles.
+ * @returns A tuple containing the current toggle state, a function to toggle the state, and a reference to the current state.
+ *
+ * @example
+ * ```jsx
+ * const [isToggled, toggle, toggleRef] = usePropToggle(false, (newState) => {
+ *   console.log("Toggle state changed to:", newState);
+ * });
+ * toggle(); // This will toggle the state and call the onToggle callback
+ * ```
  */
 export declare const usePropToggle: (isOn?: boolean, onToggle?: (is: boolean, key?: string) => unknown, key?: string) => [boolean, () => void, RefObject<boolean>];

package/dist/types/hooks/useResize.d.ts

@@ -17,11 +17,29 @@ interface Options {
      */
     onEnd?: () => void;
 }
+/**
+ * Custom hook to handle resizing of an element.
+ * It provides a ref to the element and a mouse down event handler to initiate resizing.
+ * The resizing is done by tracking mouse movements and calculating the difference in x and y coordinates.
+ * It supports both horizontal and vertical resizing, and can be configured to reverse the direction based on RTL (Right-to-Left) layout.
+ *
+ * @param onResize - callback to handle resize event with the difference in x and y
+ * @param options - options for resizing behavior
+ * @returns ref to the element and a mouse down event handler to initiate resizing
+ *
+ * @example
+ * ```jsx
+ * const { ref, onMouseDown } = useResize((diff) => {
+ *   console.log("Resize difference:", diff);
+ * }, { isReverse: true, isVertical: false });
+ * <div ref={ref} onMouseDown={onMouseDown}>Resize Me</div>
+ * ```
+ */
 export declare const useResize: <T extends HTMLElement = HTMLDivElement>(onResize: (diff: {
     x: number;
     y: number;
 }) => void, { isReverse, isVertical, onStart, onEnd }: Options) => {
-    ref: RefObject<T>;
+    ref: RefObject<T | null>;
     onMouseDown: React.MouseEventHandler;
 };
 export {};