@evoke-platform/ui-components 1.6.0-dev.1 → 1.6.0-dev.10

package/dist/published/components/custom/HistoryLog/index.d.ts

@@ -10,6 +10,8 @@ export type HistoryLogProps = {
     loading?: boolean;
     /** The title displayed above the timeline */
     title?: string;
+    /** Whether to hide the timeline in the history log */
+    hideTimeline?: boolean;
 };
 /**
  * Renders a timeline of the instance's history log.

package/dist/published/components/custom/HistoryLog/index.js

@@ -20,7 +20,7 @@ const { format } = require('small-date');
  * @returns {JSX.Element} A timeline view representing the instance's history.
  */
 export const HistoryLog = (props) => {
-    const { object, history, loading, title } = props;
+    const { object, history, loading, title, hideTimeline } = props;
     const [historyMap, setHistoryMap] = useState({});
     const [documentHistory, setDocumentHistory] = useState({});
     const [referencedObjects, setReferencedObjects] = useState([]);
@@ -91,7 +91,7 @@ export const HistoryLog = (props) => {
                 if (records.length) {
                     return (React.createElement(React.Fragment, { key: date },
                         React.createElement(Box, { sx: { display: 'flex', alignItems: 'center' } },
-                            React.createElement(Circle, { color: "primary", sx: { fontSize: '12px', marginRight: '12px' } }),
+                            !hideTimeline && (React.createElement(Circle, { color: "primary", sx: { fontSize: '12px', marginRight: '12px' } })),
                             React.createElement(Typography, { sx: { fontWeight: 600, fontSize: '16px' } },
                                 format(new Date(), 'yyyy-MM-dd') === date
                                     ? 'Today'
@@ -99,14 +99,14 @@ export const HistoryLog = (props) => {
                                 ' ',
                                 "\u00A0"),
                             React.createElement(Typography, { sx: { fontWeight: 600, fontSize: '16px', color: '#637381' } }, format(new Date(date + ' 00:00:000'), 'MMM dd, yyyy'))),
-                        React.createElement(HistoricalData, { object: object, records: records, documentHistory: documentHistory, referencedObjects: referencedObjects })));
+                        React.createElement(HistoricalData, { object: object, records: records, documentHistory: documentHistory, referencedObjects: referencedObjects, hideTimeline: hideTimeline })));
                 }
                 return null;
             }),
         !loading && filteredHistory && Object.values(filteredHistory).every((v) => !v.length) && (React.createElement(Box, { width: '100%', display: 'grid', justifyContent: 'center', marginTop: '60px' },
             React.createElement(Typography, { fontSize: '20px', fontWeight: 700 }, "You Have No History"),
             React.createElement(Typography, { fontSize: '14px', fontWeight: 400 }, "Try modifying the history type."))),
-        loading && React.createElement(HistoryLoading, null),
+        loading && React.createElement(HistoryLoading, { hideTimeline: hideTimeline }),
         React.createElement(Snackbar, { open: showSnackbar, handleClose: () => setShowSnackbar(false), message: 'Error occurred when loading referenced objects', error: true })));
 };
 export default HistoryLog;

package/dist/published/components/custom/ResponsiveOverflow/ResponsiveOverflow.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+export interface ResponsiveOverflowProps {
+    /**
+     * Children elements to be displayed horizontally
+     */
+    children: React.ReactNode[];
+    /**
+     * Text for the overflow button. Default is "More"
+     */
+    moreButtonText?: string;
+    /**
+     * Custom button element to replace the default "More" button
+     */
+    customMoreButton?: React.ReactNode;
+    /**
+     * Maximum number of children to be displayed before overflowing
+     */
+    maxVisible?: number;
+    /**
+     * Function to render each overflow menu item. Receives the overflowed child and its index.
+     */
+    renderOverflowMenuItem?: (item: React.ReactNode) => React.ReactNode;
+    /**
+     * If true, the container will take full width
+     */
+    fullWidth?: boolean;
+}
+/**
+ * ResponsiveOverflow is a container component that displays children horizontally,
+ * automatically moving overflow items into a dropdown menu when there isn't enough space.
+ */
+export declare const ResponsiveOverflow: (props: ResponsiveOverflowProps) => React.JSX.Element;
+export default ResponsiveOverflow;

package/dist/published/components/custom/ResponsiveOverflow/ResponsiveOverflow.js

@@ -0,0 +1,143 @@
+import { KeyboardArrowDownRounded } from '@mui/icons-material';
+import { Box, Menu, MenuItem } from '@mui/material';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { Button } from '../../core';
+const styles = {
+    container: {
+        display: 'flex',
+        alignItems: 'center',
+        flex: '1 1 auto',
+        minWidth: 0,
+        overflow: 'hidden',
+        justifyContent: 'flex-end',
+    },
+    moreButton: {
+        color: '#637381',
+        fontSize: '14px',
+        fontWeight: 700,
+        minWidth: 'unset',
+        '& .MuiButton-endIcon': { margin: '0px' },
+    },
+    menuPaper: {
+        border: '0.5px solid #919EAB52',
+        borderRadius: '8px',
+        minWidth: '150px',
+        boxShadow: '0px 8px 16px 0px #0000001F',
+    },
+    horizontalItems: {
+        display: 'inline-block',
+        verticalAlign: 'top',
+        whiteSpace: 'nowrap',
+    },
+    fullWidthItems: {
+        padding: '0 4px',
+        flexGrow: 1,
+    },
+};
+/**
+ * ResponsiveOverflow is a container component that displays children horizontally,
+ * automatically moving overflow items into a dropdown menu when there isn't enough space.
+ */
+export const ResponsiveOverflow = (props) => {
+    const { children, customMoreButton, maxVisible, renderOverflowMenuItem, moreButtonText, fullWidth } = props;
+    const containerRef = useRef(null);
+    const itemRefs = useRef([]);
+    const moreButtonBoxRef = useRef(null);
+    const [overflowItems, setOverflowItems] = useState([]);
+    const [anchorEl, setAnchorEl] = useState(null);
+    // Initialize refs array with correct length
+    useEffect(() => {
+        itemRefs.current = itemRefs.current.slice(0, children.length);
+        handleResize();
+    }, [children]);
+    const handleResize = useCallback(() => {
+        if (!containerRef.current)
+            return;
+        // Reset all items to visible before measuring
+        itemRefs.current.forEach((item) => {
+            if (item) {
+                item.style.display = 'inline-block';
+            }
+        });
+        const availableWidth = containerRef.current.getBoundingClientRect().width;
+        let usedWidth = 0;
+        let maxFit = children.length;
+        // Determine which items fit and which overflow
+        for (let i = 0; i < itemRefs.current.length; i++) {
+            const item = itemRefs.current[i];
+            if (!item) {
+                continue;
+            }
+            const itemWidth = item.getBoundingClientRect().width;
+            // Calculate if we need the "More" button
+            const remainingItems = itemRefs.current.length - i - 1;
+            const moreButtonWidth = remainingItems > 0 && moreButtonBoxRef.current
+                ? moreButtonBoxRef.current.getBoundingClientRect().width
+                : 0;
+            if (usedWidth + itemWidth + (remainingItems > 0 ? moreButtonWidth : 0) > availableWidth) {
+                maxFit = i;
+                break;
+            }
+            usedWidth += itemWidth;
+        }
+        // If maxVisible is set, limit the number of visible items
+        if (typeof maxVisible === 'number') {
+            maxFit = Math.min(maxFit, maxVisible);
+        }
+        const newOverflow = [];
+        itemRefs.current.forEach((item, idx) => {
+            if (!item) {
+                return;
+            }
+            else if (idx >= maxFit) {
+                item.style.display = 'none';
+                if (children[idx]) {
+                    newOverflow.push(children[idx]);
+                }
+            }
+            else {
+                item.style.display = 'inline-block';
+            }
+        });
+        setOverflowItems(newOverflow);
+        // Close menu if nothing is overflowing
+        if (newOverflow.length === 0) {
+            setAnchorEl(null);
+        }
+    }, [children, maxVisible]);
+    // Set up resize observer
+    useEffect(() => {
+        const resizeObserver = new ResizeObserver(() => {
+            requestAnimationFrame(handleResize);
+        });
+        if (containerRef.current) {
+            resizeObserver.observe(containerRef.current);
+        }
+        handleResize();
+        return () => {
+            if (containerRef.current) {
+                resizeObserver.unobserve(containerRef.current);
+            }
+            resizeObserver.disconnect();
+        };
+    }, [handleResize]);
+    const handleMenuOpen = (e) => setAnchorEl(e.currentTarget);
+    const handleMenuClose = () => setAnchorEl(null);
+    return (React.createElement(Box, { ref: containerRef, sx: styles.container },
+        children.map((item, index) => (React.createElement(Box, { ref: (el) => (itemRefs.current[index] = el), key: index, sx: { ...styles.horizontalItems, ...(fullWidth ? styles.fullWidthItems : {}) } }, item))),
+        !!overflowItems.length && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { ref: moreButtonBoxRef, onClick: anchorEl ? handleMenuClose : handleMenuOpen }, customMoreButton ?? (React.createElement(Button, { variant: "text", sx: styles.moreButton, size: "small", endIcon: React.createElement(KeyboardArrowDownRounded, null) }, moreButtonText ?? 'More'))),
+            React.createElement(Menu, { anchorEl: anchorEl, open: Boolean(anchorEl), onClose: handleMenuClose, disablePortal: false, disableScrollLock: true, keepMounted: true, anchorOrigin: {
+                    vertical: 'bottom',
+                    horizontal: 'right',
+                }, transformOrigin: {
+                    vertical: 'top',
+                    horizontal: 'right',
+                }, sx: { '& .MuiPaper-root': styles.menuPaper } }, overflowItems.map((item, idx) => {
+                if (renderOverflowMenuItem) {
+                    return renderOverflowMenuItem(item);
+                }
+                return (React.createElement(MenuItem, { key: idx, onClick: handleMenuClose }, item));
+            }))))));
+};
+export default ResponsiveOverflow;

package/dist/published/components/custom/ResponsiveOverflow/ResponsiveOverflow.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/dist/published/components/custom/ResponsiveOverflow/ResponsiveOverflow.test.js

@@ -0,0 +1,100 @@
+import '@testing-library/jest-dom';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+import { vi } from 'vitest';
+import Button from '../../core/Button/Button';
+import ResponsiveOverflow from './ResponsiveOverflow';
+let mockResizeCallback = null;
+const originalResizeObserver = global.ResizeObserver;
+const originalGetBoundingClientRect = Element.prototype.getBoundingClientRect;
+describe('ResponsiveOverflow', () => {
+    // Helper function to simulate resize events
+    const simulateResize = (width) => {
+        Element.prototype.getBoundingClientRect = vi.fn(() => ({
+            width,
+        }));
+        if (mockResizeCallback) {
+            mockResizeCallback([], {});
+        }
+    };
+    beforeEach(() => {
+        mockResizeCallback = null;
+        global.ResizeObserver = class ResizeObserver {
+            constructor(callback) {
+                mockResizeCallback = callback;
+            }
+            observe() { }
+            unobserve() { }
+            disconnect() { }
+        };
+    });
+    afterEach(() => {
+        global.ResizeObserver = originalResizeObserver;
+        Element.prototype.getBoundingClientRect = originalGetBoundingClientRect;
+    });
+    it('renders children correctly', () => {
+        render(React.createElement(ResponsiveOverflow, null,
+            React.createElement(Button, null, "Button 1"),
+            React.createElement(Button, null, "Button 2"),
+            React.createElement(Button, null, "Button 3")));
+        expect(screen.getByText('Button 1')).toBeInTheDocument();
+        expect(screen.getByText('Button 2')).toBeInTheDocument();
+        expect(screen.getByText('Button 3')).toBeInTheDocument();
+    });
+    it('displays custom button text when overflowing', async () => {
+        render(React.createElement(ResponsiveOverflow, { moreButtonText: "Show More" },
+            React.createElement(Button, null, "Button 1"),
+            React.createElement(Button, null, "Button 2"),
+            React.createElement(Button, null, "Button 3"),
+            React.createElement(Button, null, "Button 4")));
+        simulateResize(80); // Narrow width to force overflow
+        await screen.findByRole('button', { name: 'Show More' });
+    });
+    it('displays custom more button when overflowing', async () => {
+        const customButton = React.createElement(Button, { "data-testid": "custom-more" }, "Custom More");
+        render(React.createElement(ResponsiveOverflow, { customMoreButton: customButton },
+            React.createElement(Button, null, "Button 1"),
+            React.createElement(Button, null, "Button 2"),
+            React.createElement(Button, null, "Button 3"),
+            React.createElement(Button, null, "Button 4")));
+        simulateResize(80);
+        await screen.findByRole('button', { name: 'Custom More' });
+    });
+    it('shows More button when triggered by ResizeObserver', async () => {
+        render(React.createElement(ResponsiveOverflow, { moreButtonText: "More" },
+            React.createElement(Button, null, "Button 1"),
+            React.createElement(Button, null, "Button 2"),
+            React.createElement(Button, null, "Button 3"),
+            React.createElement(Button, null, "Button 4"),
+            React.createElement(Button, null, "Button 5"),
+            React.createElement(Button, null, "Button 6"),
+            React.createElement(Button, null, "Button 7"),
+            React.createElement(Button, null, "Button 8"),
+            React.createElement(Button, null, "Button 9"),
+            React.createElement(Button, null, "Button 10")));
+        simulateResize(80);
+        const moreBtn = await screen.findByRole('button', { name: 'More' });
+        await screen.findByRole('button', { name: 'Button 1' });
+        await userEvent.click(moreBtn);
+        // Button 9 should be in the overflow menu as a menuitem
+        await screen.findByRole('menuitem', { name: 'Button 9' });
+    });
+    it('handles dynamic resizing from wide to narrow conditions', async () => {
+        render(React.createElement(ResponsiveOverflow, { moreButtonText: "More" },
+            React.createElement(Button, null, "Button 1"),
+            React.createElement(Button, null, "Button 2"),
+            React.createElement(Button, null, "Button 3"),
+            React.createElement(Button, null, "Button 4"),
+            React.createElement(Button, null, "Button 5"),
+            React.createElement(Button, null, "Button 6")));
+        simulateResize(800);
+        // With wide container, all buttons should fit
+        // More button should not be visible
+        expect(screen.queryByRole('button', { name: 'More' })).not.toBeInTheDocument();
+        // Now simulate narrow conditions - force overflow
+        simulateResize(200);
+        // With narrow container, More button should now be visible
+        await screen.findByRole('button', { name: 'More' });
+    });
+});

package/dist/published/components/custom/ResponsiveOverflow/index.d.ts

@@ -0,0 +1,4 @@
+import ResponsiveOverflow, { ResponsiveOverflowProps } from './ResponsiveOverflow';
+export { ResponsiveOverflow };
+export type { ResponsiveOverflowProps };
+export default ResponsiveOverflow;

package/dist/published/components/custom/ResponsiveOverflow/index.js

@@ -0,0 +1,3 @@
+import ResponsiveOverflow from './ResponsiveOverflow';
+export { ResponsiveOverflow };
+export default ResponsiveOverflow;

package/dist/published/components/custom/index.d.ts

@@ -9,5 +9,6 @@ export { HistoryLog } from './HistoryLog';
 export { MenuBar } from './Menubar';
 export { MultiSelect } from './MultiSelect';
 export { RepeatableField } from './RepeatableField';
+export { ResponsiveOverflow } from './ResponsiveOverflow';
 export { RichTextViewer } from './RichTextViewer';
 export { UserAvatar } from './UserAvatar';

package/dist/published/components/custom/index.js

@@ -8,5 +8,6 @@ export { HistoryLog } from './HistoryLog';
 export { MenuBar } from './Menubar';
 export { MultiSelect } from './MultiSelect';
 export { RepeatableField } from './RepeatableField';
+export { ResponsiveOverflow } from './ResponsiveOverflow';
 export { RichTextViewer } from './RichTextViewer';
 export { UserAvatar } from './UserAvatar';

package/dist/published/index.d.ts

@@ -2,7 +2,7 @@ export { ClickAwayListener, createTheme, darken, lighten, styled, Toolbar, useMe
 export { CalendarPicker, DateTimePicker, MonthPicker, PickersDay, StaticDateTimePicker, StaticTimePicker, TimePicker, YearPicker, } from '@mui/x-date-pickers';
 export * from './colors';
 export * from './components/core';
-export { BuilderGrid, CriteriaBuilder, DataGrid, ErrorComponent, Form, FormField, getReadableQuery, HistoryLog, MenuBar, MultiSelect, RepeatableField, RichTextViewer, UserAvatar, } from './components/custom';
+export { BuilderGrid, CriteriaBuilder, DataGrid, ErrorComponent, Form, FormField, getReadableQuery, HistoryLog, MenuBar, MultiSelect, RepeatableField, ResponsiveOverflow, RichTextViewer, UserAvatar, } from './components/custom';
 export type { FormRef } from './components/custom';
 export { NumericFormat } from './components/custom/FormField/InputFieldComponent';
 export { Box, Container, Grid, Stack } from './components/layout';

package/dist/published/index.js

@@ -2,7 +2,7 @@ export { ClickAwayListener, createTheme, darken, lighten, styled, Toolbar, useMe
 export { CalendarPicker, DateTimePicker, MonthPicker, PickersDay, StaticDateTimePicker, StaticTimePicker, TimePicker, YearPicker, } from '@mui/x-date-pickers';
 export * from './colors';
 export * from './components/core';
-export { BuilderGrid, CriteriaBuilder, DataGrid, ErrorComponent, Form, FormField, getReadableQuery, HistoryLog, MenuBar, MultiSelect, RepeatableField, RichTextViewer, UserAvatar, } from './components/custom';
+export { BuilderGrid, CriteriaBuilder, DataGrid, ErrorComponent, Form, FormField, getReadableQuery, HistoryLog, MenuBar, MultiSelect, RepeatableField, ResponsiveOverflow, RichTextViewer, UserAvatar, } from './components/custom';
 export { NumericFormat } from './components/custom/FormField/InputFieldComponent';
 export { Box, Container, Grid, Stack } from './components/layout';
 export * from './theme';

package/dist/published/stories/ResponsiveOverflow.stories.d.ts

@@ -0,0 +1,8 @@
+import { Meta, Story } from '@storybook/react';
+import React from 'react';
+import { ResponsiveOverflowProps } from '../components/custom/ResponsiveOverflow';
+declare const _default: Meta<import("@storybook/react").Args>;
+export default _default;
+export declare const ResizableDemo: () => React.JSX.Element;
+export declare const WithLinks: Story<ResponsiveOverflowProps>;
+export declare const WithCustomMoreButton: Story<ResponsiveOverflowProps>;

package/dist/published/stories/ResponsiveOverflow.stories.js

@@ -0,0 +1,91 @@
+import { KeyboardArrowDownRounded } from '@mui/icons-material';
+import { Box, Paper, Typography } from '@mui/material';
+import React, { useState } from 'react';
+import Button from '../components/core/Button/Button';
+import Link from '../components/core/Link/Link';
+import ResponsiveOverflow from '../components/custom/ResponsiveOverflow';
+export default {
+    title: 'Custom/ResponsiveOverflow',
+    component: ResponsiveOverflow,
+    parameters: {
+        componentSubtitle: 'A container that handles overflow with a dropdown menu',
+    },
+    argTypes: {
+        moreButtonText: {
+            control: 'text',
+            description: 'Text for the overflow button',
+            defaultValue: 'More',
+        },
+        customMoreButton: {
+            control: false,
+            description: 'Custom button element to replace the default More button',
+        },
+        children: {
+            control: false,
+            description: 'React elements to display in the container',
+        },
+    },
+};
+const Template = (args) => React.createElement(ResponsiveOverflow, { ...args });
+// Interactive demo with resizable container
+export const ResizableDemo = () => {
+    const [width, setWidth] = useState(800);
+    const handleChange = (event) => {
+        setWidth(Number(event.target.value));
+    };
+    return (React.createElement(Box, null,
+        React.createElement(Typography, { variant: "h6", gutterBottom: true }, "Resize Container"),
+        React.createElement(Box, { sx: { mb: 2 } },
+            React.createElement(Typography, { variant: "body2", gutterBottom: true },
+                "Container Width: ",
+                width,
+                "px"),
+            React.createElement("input", { type: "range", min: 200, max: 1000, value: width, onChange: handleChange, 
+                // eslint-disable-next-line no-inline-styles/no-inline-styles
+                style: { width: '100%' }, "aria-label": "Adjust container width", title: "Drag to resize container" })),
+        React.createElement(Paper, { elevation: 1, sx: {
+                width: `${width}px`,
+                padding: 2,
+                transition: 'width 0.3s ease',
+                backgroundColor: '#f5f5f5',
+            } },
+            React.createElement(ResponsiveOverflow, { moreButtonText: "More" },
+                React.createElement(Button, { variant: "contained", color: "primary" }, "Dashboard"),
+                React.createElement(Button, { variant: "contained" }, "Applications"),
+                React.createElement(Button, { variant: "contained" }, "Inspections"),
+                React.createElement(Button, { variant: "contained" }, "Reports"),
+                React.createElement(Button, { variant: "contained" }, "Licenses"),
+                React.createElement(Button, { variant: "contained" }, "Permits"),
+                React.createElement(Button, { variant: "contained" }, "Requests"),
+                React.createElement(Button, { variant: "contained" }, "Locations")))));
+};
+export const WithLinks = Template.bind({});
+WithLinks.args = {
+    moreButtonText: 'More',
+    children: [
+        React.createElement(Link, { key: "1" }, "Applications"),
+        React.createElement(Link, { key: "2" }, "Inspections"),
+        React.createElement(Link, { key: "3" }, "Licenses"),
+        React.createElement(Link, { key: "4" }, "Permits"),
+        React.createElement(Link, { key: "5" }, "Requests"),
+        React.createElement(Link, { key: "6" }, "Compliance"),
+    ],
+};
+export const WithCustomMoreButton = Template.bind({});
+WithCustomMoreButton.args = {
+    customMoreButton: (React.createElement(Button, { variant: "contained", endIcon: React.createElement(KeyboardArrowDownRounded, null) }, "More Options")),
+    children: [
+        React.createElement(Button, { variant: "contained", color: "primary", key: "1" }, "Dashboard"),
+        React.createElement(Button, { variant: "contained", key: "2" }, "Applications"),
+        React.createElement(Button, { variant: "contained", key: "3" }, "Inspections"),
+        React.createElement(Button, { variant: "contained", key: "4" }, "Reports"),
+        React.createElement(Button, { variant: "contained", key: "5" }, "Licenses"),
+        React.createElement(Button, { variant: "contained", key: "6" }, "Permits"),
+        React.createElement(Button, { variant: "contained", key: "7" }, "Requests"),
+        React.createElement(Button, { variant: "contained", key: "8" }, "Documents"),
+        React.createElement(Button, { variant: "contained", key: "9" }, "Locations"),
+        React.createElement(Button, { variant: "contained", key: "10" }, "Calendar"),
+        React.createElement(Button, { variant: "contained", key: "11" }, "Compliance"),
+        React.createElement(Button, { variant: "contained", key: "12" }, "Notifications"),
+    ],
+};

package/dist/published/theme/hooks.d.ts

@@ -29,3 +29,81 @@ export declare function useResponsive(): {
     /** Returns true if viewport width is between the specified breakpoints */
     between: (start: Breakpoint, end: Breakpoint) => boolean;
 };
+export interface WidgetSizeInfo {
+    /** The ref to attach to the widget container */
+    ref: (element: HTMLElement | SVGElement | null) => void;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Widget size breakpoints */
+    breakpoints: {
+        /** Extra small: width < 800px */
+        isXs: boolean;
+        /** Small: 800px <= width < 1000px */
+        isSm: boolean;
+        /** Medium: 1000px <= width < 1200px */
+        isMd: boolean;
+        /** Large: 1200px <= width < 1400px */
+        isLg: boolean;
+        /** Extra large: width >= 1400px */
+        isXl: boolean;
+        /** Compact height: height < 300px */
+        isCompact: boolean;
+        /** Tall height: height >= 600px */
+        isTall: boolean;
+    };
+    /** Bounds information from react-use-measure */
+    bounds: {
+        /**
+         * left is usually the same as x, but can differ if width is negative.
+         * See: https://developer.mozilla.org/en-US/docs/Web/API/DOMRect
+         */
+        left: number;
+        /**
+         * top is usually the same as y, but can differ if height is negative.
+         * See: https://developer.mozilla.org/en-US/docs/Web/API/DOMRect
+         */
+        top: number;
+        width: number;
+        height: number;
+        bottom: number;
+        right: number;
+        x: number;
+        y: number;
+    };
+    /** Check if widget is above a breakpoint */
+    isAbove: (breakpoint: 'xs' | 'sm' | 'md' | 'lg' | 'xl') => boolean;
+    /** Check if widget is below a breakpoint */
+    isBelow: (breakpoint: 'xs' | 'sm' | 'md' | 'lg' | 'xl') => boolean;
+}
+/**
+ * Custom hook that measures widget dimensions and provides responsive breakpoints
+ * based on the actual widget size rather than viewport size.
+ *
+ * @param options Configuration options for the measurement
+ * @returns WidgetSizeInfo object with ref, dimensions, and breakpoints
+ *
+ * @example
+ * ```tsx
+ * const { ref, width, breakpoints } = useWidgetSize();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     {breakpoints.isXs ? 'Compact view' : 'Full view'}
+ *     <p>Widget width: {width}px</p>
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useWidgetSize: (options?: {
+    /** Debounce measurement updates (ms) */
+    debounce?: number;
+    /** Throttle measurement updates (ms) */
+    throttle?: number;
+    /** Scroll containers to observe */
+    scroll?: boolean;
+    /** Resize containers to observe */
+    resize?: boolean;
+}) => WidgetSizeInfo;
+export default useWidgetSize;

package/dist/published/theme/hooks.js

@@ -1,5 +1,6 @@
 import { useTheme } from '@mui/material';
 import useMediaQuery from '@mui/material/useMediaQuery';
+import useMeasure from 'react-use-measure';
 /**
  * Custom hook for responsive design breakpoints using size terminology.
  * Breakpoints based on MUI default theme:
@@ -33,3 +34,67 @@ export function useResponsive() {
         between: (start, end) => useMediaQuery(theme.breakpoints.between(start, end)),
     };
 }
+/**
+ * Custom hook that measures widget dimensions and provides responsive breakpoints
+ * based on the actual widget size rather than viewport size.
+ *
+ * @param options Configuration options for the measurement
+ * @returns WidgetSizeInfo object with ref, dimensions, and breakpoints
+ *
+ * @example
+ * ```tsx
+ * const { ref, width, breakpoints } = useWidgetSize();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     {breakpoints.isXs ? 'Compact view' : 'Full view'}
+ *     <p>Widget width: {width}px</p>
+ *   </div>
+ * );
+ * ```
+ */
+export const useWidgetSize = (options) => {
+    const [ref, bounds] = useMeasure({
+        debounce: options?.debounce ?? 16,
+        scroll: options?.scroll ?? true,
+        offsetSize: true,
+        ...options,
+    });
+    const width = bounds.width || 0;
+    const height = bounds.height || 0;
+    // Widget-specific breakpoints based on container width
+    const breakpoints = {
+        isXs: width < 800,
+        isSm: width >= 800 && width < 1000,
+        isMd: width >= 1000 && width < 1200,
+        isLg: width >= 1200 && width < 1400,
+        isXl: width >= 1400,
+        isCompact: height < 300,
+        isTall: height >= 600,
+    };
+    // Breakpoint thresholds
+    const breakpointThresholds = {
+        xs: 800,
+        sm: 1000,
+        md: 1200,
+        lg: 1400,
+        xl: Infinity,
+    };
+    // Utility functions for responsive checks
+    const isAbove = (breakpoint) => {
+        return width >= breakpointThresholds[breakpoint];
+    };
+    const isBelow = (breakpoint) => {
+        return width < breakpointThresholds[breakpoint];
+    };
+    return {
+        ref,
+        width,
+        height,
+        breakpoints,
+        bounds,
+        isAbove,
+        isBelow,
+    };
+};
+export default useWidgetSize;

package/dist/published/theme/hooks.test.d.ts

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