react-split-pane 2.0.3 → 3.0.0

package/README.md

@@ -1,183 +1,381 @@
-# React Split Pane
+# React Split Pane v3
 
-Split-Pane component built with [React](http://facebook.github.io/react), can be split vertically or horizontally.
+Modern, accessible, TypeScript-first split pane component for React.
 
+[![NPM version](https://img.shields.io/npm/v/react-split-pane.svg?style=flat)](https://www.npmjs.com/package/react-split-pane)
+![NPM license](https://img.shields.io/npm/l/react-split-pane.svg?style=flat)
+[![Bundle size](https://img.shields.io/bundlephobia/minzip/react-split-pane)](https://bundlephobia.com/package/react-split-pane)
+
+**[Live Examples](https://tomkp.github.io/react-split-pane)**
+
+## ✨ Features
+
+- 🪝 **Hooks-based** - Built with modern React patterns
+- 📘 **TypeScript** - Full type safety out of the box
+- ♿ **Accessible** - Keyboard navigation, ARIA attributes, screen reader support
+- 📱 **Touch-friendly** - Full mobile/tablet support
+- 🎯 **Flexible** - Controlled/uncontrolled modes, nested layouts, 2+ panes
+- 🪶 **Lightweight** - < 5KB gzipped
+- ⚡ **Performant** - RAF-throttled resize, optimized renders
+- 🎨 **Customizable** - Full styling control
+
+## Installation
+
+```bash
+npm install react-split-pane@next
+
+# or
+yarn add react-split-pane@next
+
+# or
+pnpm add react-split-pane@next
 ```
-npm install react-split-pane
+
+## Quick Start
+
+```tsx
+import { SplitPane, Pane } from 'react-split-pane';
+
+function App() {
+  return (
+    <SplitPane direction="horizontal">
+      <Pane minSize="200px" defaultSize="300px">
+        <Sidebar />
+      </Pane>
+      <Pane>
+        <MainContent />
+      </Pane>
+    </SplitPane>
+  );
+}
 ```
 
-[![Build Status](https://img.shields.io/travis/tomkp/react-split-pane/master.svg?style=flat-square)](https://travis-ci.org/tomkp/react-split-pane)
-[![Coverage Status](https://img.shields.io/coveralls/tomkp/react-split-pane/master.svg?style=flat-square)](https://coveralls.io/r/tomkp/react-split-pane)
+## Basic Usage
 
+### Horizontal Split (Side-by-Side)
 
-Check out the [demos](http://react-split-pane.surge.sh/)
+```tsx
+<SplitPane direction="horizontal">
+  <Pane defaultSize="25%">
+    <LeftPanel />
+  </Pane>
+  <Pane>
+    <RightPanel />
+  </Pane>
+</SplitPane>
+```
+
+### Vertical Split (Top-Bottom)
+
+```tsx
+<SplitPane direction="vertical">
+  <Pane defaultSize="100px">
+    <Header />
+  </Pane>
+  <Pane>
+    <Content />
+  </Pane>
+</SplitPane>
+```
 
+### Controlled Mode
 
-```html
-   <SplitPane split="vertical" minSize={50} defaultSize={100}>
-       <div></div>
-       <div></div>
-   </SplitPane>
+```tsx
+function App() {
+  const [sizes, setSizes] = useState([300, 500]);
+
+  return (
+    <SplitPane onResize={setSizes}>
+      <Pane size={sizes[0]} minSize="200px">
+        <Sidebar />
+      </Pane>
+      <Pane size={sizes[1]}>
+        <Main />
+      </Pane>
+    </SplitPane>
+  );
+}
 ```
 
-```html
-    <SplitPane split="vertical" minSize={50}>
-        <div></div>
-        <SplitPane split="horizontal">
-            <div></div>
-            <div></div>
-        </SplitPane>
+### Nested Layouts
+
+```tsx
+<SplitPane direction="vertical">
+  <Pane defaultSize="60px">
+    <Header />
+  </Pane>
+
+  <SplitPane direction="horizontal">
+    <Pane defaultSize="250px" minSize="150px">
+      <Sidebar />
+    </Pane>
+
+    <SplitPane direction="vertical">
+      <Pane>
+        <Editor />
+      </Pane>
+      <Pane defaultSize="200px">
+        <Console />
+      </Pane>
     </SplitPane>
+  </SplitPane>
+</SplitPane>
 ```
 
-### Primary pane
+## Advanced Features
 
-By dragging 'draggable' surface you can change size of the first pane.
-The first pane keeps then its size while the second pane is resized by browser window.
-By default it is the left pane for 'vertical' SplitPane and the top pane for 'horizontal' SplitPane.
-If you want to keep size of the second pane and let the first pane to shrink or grow by browser window dimensions,
-set SplitPane prop `primary` to `second`. In case of 'horizontal' SplitPane the height of bottom pane remains the same.
+### Persistence
 
-Resizing can be disabled by passing the `allowResize` prop as `false` (`allowResize={false}`). Resizing is enabled by default.
+The `usePersistence` hook saves and restores pane sizes to localStorage (or sessionStorage):
 
-You can also set the size of the pane using the `size` prop. Note that a size set through props ignores the `defaultSize` and `minSize` properties.
+```tsx
+import { usePersistence } from 'react-split-pane/persistence';
 
-In this example right pane keeps its width 200px while user is resizing browser window.
+function App() {
+  const [sizes, setSizes] = usePersistence({ key: 'my-layout' });
 
-```html
-    <SplitPane split="vertical" defaultSize={200} primary="second">
-        <div></div>
-        <div></div>
+  return (
+    <SplitPane onResize={setSizes}>
+      <Pane size={sizes[0] || 300}>
+        <Sidebar />
+      </Pane>
+      <Pane size={sizes[1]}>
+        <Main />
+      </Pane>
     </SplitPane>
+  );
+}
 ```
 
-### maxSize
-You can limit the maximal size of the 'fixed' pane using the maxSize parameter with a positive value (measured in pixels but state just a number).
-If you wrap the SplitPane into a container component (yes you can, just remember the container has to have the relative or absolute positioning),
-then you'll need to limit the movement of the splitter (resizer) at the end of the SplitPane (otherwise it can be dragged outside the SplitPane
-and you don't catch it never more). For this purpose use the maxSize parameter with value 0. When dragged the splitter/resizer will stop at the border
-of the SplitPane component and think this you'll be able to pick it again and drag it back then.
-And more: if you set the maxSize to negative value (e.g. -200), then the splitter stops 200px before the border (in other words it sets the minimal
-size of the 'resizable' pane in this case). This can be useful also in the full-screen case of use.
+#### usePersistence Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `key` | `string` | Required | Storage key for persisting sizes |
+| `storage` | `Storage` | `localStorage` | Storage backend (localStorage or sessionStorage) |
+| `debounce` | `number` | `300` | Debounce delay in ms before saving |
+
+```tsx
+// Use sessionStorage instead of localStorage
+const [sizes, setSizes] = usePersistence({
+  key: 'my-layout',
+  storage: sessionStorage,
+  debounce: 500,
+});
+```
 
-### step
-You can use the step prop to only allow resizing in fixed increments.
+### Snap Points
 
-### Persisting Positions
+```tsx
+<SplitPane
+  snapPoints={[200, 400, 600]}
+  snapTolerance={20}
+>
+  {/* panes */}
+</SplitPane>
+```
 
-Each SplitPane accepts an onChange function prop.  Used in conjunction with
-defaultSize and a persistence layer, you can ensure that your splitter choices
-survive a refresh of your app.
+### Custom Divider
 
-For example, if you are comfortable with the trade-offs of localStorage, you
-could do something like the following:
+```tsx
+function CustomDivider(props) {
+  return (
+    <div {...props} style={{ ...props.style, background: 'blue' }}>
+      <GripIcon />
+    </div>
+  );
+}
 
-```html
-    <SplitPane split="vertical" minSize={50}
-               defaultSize={ parseInt(localStorage.getItem('splitPos'), 10) }
-               onChange={ size => localStorage.setItem('splitPos', size) }>
-        <div></div>
-        <div></div>
-    </SplitPane>
+<SplitPane divider={CustomDivider}>
+  {/* panes */}
+</SplitPane>
 ```
 
-Disclaimer: localStorage has a variety of performance trade-offs.  Browsers such
-as Firefox have now optimized localStorage use so that they will asynchronously
-initiate a read of all saved localStorage data for an origin once they know the
-page will load.  If the data has not fully loaded by the time code accesses
-localStorage, the code will cause the page's main thread to block until the
-database load completes.  When the main thread is blocked, no other JS code will
-run or layout will occur.  In multiprocess browsers and for users with fast
-disk storage, this will be less of a problem.  You *are* likely to get yelled at
-if you use localStorage.
+## Keyboard Navigation
+
+The divider is fully keyboard accessible:
+
+- **Arrow Keys**: Resize by `step` pixels (default: 10px)
+- **Shift + Arrow**: Resize by larger step (default: 50px)
+- **Home**: Minimize left/top pane
+- **End**: Maximize left/top pane
+- **Tab**: Navigate between dividers
 
-A potentially better idea is to use something like
-https://github.com/mozilla/localForage although hooking it up will be slightly
-more involved.  You are likely to be admired by all for judiciously avoiding
-use of localStorage.
+## API Reference
 
-### Resizing callbacks
+### SplitPane Props
 
-If you need more control over resizing, SplitPane can notify you about when resizing started
-and when it ended through two callbacks: `onDragStarted` and `onDragFinished`.
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `direction` | `'horizontal' \| 'vertical'` | `'horizontal'` | Layout direction |
+| `resizable` | `boolean` | `true` | Whether panes can be resized |
+| `snapPoints` | `number[]` | `[]` | Snap points in pixels |
+| `snapTolerance` | `number` | `10` | Snap tolerance in pixels |
+| `step` | `number` | `10` | Keyboard resize step |
+| `onResizeStart` | `(event) => void` | - | Called when resize starts |
+| `onResize` | `(sizes, event) => void` | - | Called during resize |
+| `onResizeEnd` | `(sizes, event) => void` | - | Called when resize ends |
+| `className` | `string` | - | CSS class name |
+| `style` | `CSSProperties` | - | Inline styles |
+| `divider` | `ComponentType` | - | Custom divider component |
+| `dividerClassName` | `string` | - | Divider class name |
+| `dividerStyle` | `CSSProperties` | - | Divider inline styles |
 
-### Example styling
+### Pane Props
 
-This gives a single pixel wide divider, but with a 'grabbable' surface of 11 pixels.
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `defaultSize` | `string \| number` | `'50%'` | Initial size (uncontrolled) |
+| `size` | `string \| number` | - | Controlled size |
+| `minSize` | `string \| number` | `0` | Minimum size |
+| `maxSize` | `string \| number` | `Infinity` | Maximum size |
+| `className` | `string` | - | CSS class name |
+| `style` | `CSSProperties` | - | Inline styles |
 
-Thanks to ```background-clip: padding-box;``` for making transparent borders possible.
+## Styling
 
+### Default Stylesheet
+
+Import the optional default styles with CSS custom properties:
+
+```tsx
+import 'react-split-pane/styles.css';
+```
+
+Customize via CSS variables:
 
 ```css
+.my-split-pane {
+  --split-pane-divider-size: 8px;
+  --split-pane-divider-color: #e0e0e0;
+  --split-pane-divider-color-hover: #b0b0b0;
+  --split-pane-focus-color: #2196f3;
+}
+```
+
+The default styles include dark mode support via `prefers-color-scheme`.
+
+### Basic Styles
+
+```css
+.split-pane {
+  height: 100vh;
+}
+
+.split-pane-divider {
+  background: #e0e0e0;
+  transition: background 0.2s;
+}
+
+.split-pane-divider:hover {
+  background: #b0b0b0;
+}
+
+.split-pane-divider:focus {
+  outline: 2px solid #2196f3;
+  outline-offset: -2px;
+}
+```
+
+### Expanded Hover Area
+
+This classic pattern creates a thin visible divider with a larger grabbable area that reveals on hover:
+
+```css
+.split-pane-divider {
+  background: #000;
+  opacity: 0.2;
+  z-index: 1;
+  box-sizing: border-box;
+  background-clip: padding-box;
+}
+
+.split-pane-divider:hover {
+  transition: all 0.2s ease;
+}
+
+.split-pane-divider.horizontal {
+  width: 11px;
+  margin: 0 -5px;
+  border-left: 5px solid rgba(255, 255, 255, 0);
+  border-right: 5px solid rgba(255, 255, 255, 0);
+  cursor: col-resize;
+}
+
+.split-pane-divider.horizontal:hover {
+  border-left: 5px solid rgba(0, 0, 0, 0.5);
+  border-right: 5px solid rgba(0, 0, 0, 0.5);
+}
+
+.split-pane-divider.vertical {
+  height: 11px;
+  margin: -5px 0;
+  border-top: 5px solid rgba(255, 255, 255, 0);
+  border-bottom: 5px solid rgba(255, 255, 255, 0);
+  cursor: row-resize;
+}
+
+.split-pane-divider.vertical:hover {
+  border-top: 5px solid rgba(0, 0, 0, 0.5);
+  border-bottom: 5px solid rgba(0, 0, 0, 0.5);
+}
+```
+
+### Minimal Divider
+
+A subtle single-pixel divider:
+
+```css
+.split-pane-divider.horizontal {
+  width: 1px;
+  margin: 0;
+  background: linear-gradient(to right, transparent, #ccc, transparent);
+}
+
+.split-pane-divider.vertical {
+  height: 1px;
+  margin: 0;
+  background: linear-gradient(to bottom, transparent, #ccc, transparent);
+}
+```
+
+## Migration from v0.1.x
+
+See [MIGRATION.md](./MIGRATION.md) for detailed migration guide.
+
+**Quick changes:**
+
+```tsx
+// v0.1.x
+<SplitPane split="vertical" minSize={50} defaultSize={100}>
+  <div>Pane 1</div>
+  <div>Pane 2</div>
+</SplitPane>
+
+// v3
+<SplitPane direction="horizontal">
+  <Pane minSize="50px" defaultSize="100px">
+    <div>Pane 1</div>
+  </Pane>
+  <Pane>
+    <div>Pane 2</div>
+  </Pane>
+</SplitPane>
+```
+
+## Browser Support
+
+- Chrome/Edge (latest 2 versions)
+- Firefox (latest 2 versions)
+- Safari (latest 2 versions)
+- Mobile browsers (iOS Safari, Chrome Android)
+
+**Note:** IE11 is not supported. Use v0.1.x for IE11 compatibility.
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
 
-    .Resizer {
-        background: #000;
-        opacity: .2;
-        z-index: 1;
-        -moz-box-sizing: border-box;
-        -webkit-box-sizing: border-box;
-        box-sizing: border-box;
-        -moz-background-clip: padding;
-        -webkit-background-clip: padding;
-        background-clip: padding-box;
-    }
-
-     .Resizer:hover {
-        -webkit-transition: all 2s ease;
-        transition: all 2s ease;
-    }
-
-     .Resizer.horizontal {
-        height: 11px;
-        margin: -5px 0;
-        border-top: 5px solid rgba(255, 255, 255, 0);
-        border-bottom: 5px solid rgba(255, 255, 255, 0);
-        cursor: row-resize;
-        width: 100%;
-    }
-
-    .Resizer.horizontal:hover {
-        border-top: 5px solid rgba(0, 0, 0, 0.5);
-        border-bottom: 5px solid rgba(0, 0, 0, 0.5);
-    }
-
-    .Resizer.vertical {
-        width: 11px;
-        margin: 0 -5px;
-        border-left: 5px solid rgba(255, 255, 255, 0);
-        border-right: 5px solid rgba(255, 255, 255, 0);
-        cursor: col-resize;
-    }
-
-    .Resizer.vertical:hover {
-        border-left: 5px solid rgba(0, 0, 0, 0.5);
-        border-right: 5px solid rgba(0, 0, 0, 0.5);
-    }
-    .Resizer.disabled {
-      cursor: not-allowed;
-    }
-    .Resizer.disabled:hover {
-      border-color: transparent;
-    }
-
- ```
-### Inline Styles
-
-You can also pass inline styles to the components via props. These are:
-
- * `paneStyle` - Styling to be applied to both panes
- * `pane1Style` - Styling to be applied to the first pane, with precedence over `paneStyle`
- * `pane2Style` - Styling to be applied to the second pane, with precedence over `paneStyle`
- * `resizerStyle` - Styling to be applied to the resizer bar
-
-
-### Contributing
-
-I'm always happy to receive Pull Requests for contributions of any kind. 
-
-Please include tests and/or update the examples if possible.
-  
-I've been working on an updated version of this library - if you'd like to get involved in any way please ping me a message.    
-  
-Thanks, Tom  
-  
+MIT © [tomkp](https://github.com/tomkp)

package/dist/components/Divider.d.ts

@@ -0,0 +1,31 @@
+import type { DividerProps } from '../types';
+/**
+ * The divider component that separates panes and handles resize interactions.
+ *
+ * This component is automatically rendered between panes by SplitPane.
+ * You can provide a custom divider via the `divider` prop on SplitPane.
+ *
+ * Features:
+ * - Keyboard accessible (arrow keys, Home, End)
+ * - Touch-friendly for mobile devices
+ * - ARIA attributes for screen readers
+ *
+ * @example
+ * ```tsx
+ * // Custom divider component
+ * function CustomDivider(props: DividerProps) {
+ *   return (
+ *     <div {...props} className="my-divider">
+ *       <GripIcon />
+ *     </div>
+ *   );
+ * }
+ *
+ * <SplitPane divider={CustomDivider}>
+ *   <Pane>Left</Pane>
+ *   <Pane>Right</Pane>
+ * </SplitPane>
+ * ```
+ */
+export declare function Divider(props: DividerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Divider.d.ts.map

package/dist/components/Divider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Divider.d.ts","sourceRoot":"","sources":["../../src/components/Divider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAQ7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,2CAgF1C"}

package/dist/components/Pane.d.ts

@@ -0,0 +1,27 @@
+import type { PaneProps } from '../types';
+/**
+ * A pane component that must be used as a direct child of SplitPane.
+ *
+ * Panes can have size constraints and can be either controlled (with `size`)
+ * or uncontrolled (with `defaultSize`).
+ *
+ * @example
+ * ```tsx
+ * // Uncontrolled with constraints
+ * <Pane minSize="100px" maxSize="500px" defaultSize="300px">
+ *   Content here
+ * </Pane>
+ *
+ * // Controlled
+ * <Pane size={sizes[0]} minSize={100}>
+ *   Content here
+ * </Pane>
+ *
+ * // Percentage-based sizing
+ * <Pane defaultSize="25%" minSize="10%">
+ *   Sidebar
+ * </Pane>
+ * ```
+ */
+export declare const Pane: import("react").ForwardRefExoticComponent<PaneProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=Pane.d.ts.map

package/dist/components/Pane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pane.d.ts","sourceRoot":"","sources":["../../src/components/Pane.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,sGA0ChB,CAAC"}

package/dist/components/SplitPane.d.ts

@@ -0,0 +1,29 @@
+import type { SplitPaneProps } from '../types';
+/**
+ * A flexible split pane component that allows resizable pane layouts.
+ *
+ * Supports horizontal (side-by-side) and vertical (stacked) layouts with
+ * mouse, touch, and keyboard interactions. Fully accessible with ARIA attributes.
+ *
+ * @example
+ * ```tsx
+ * // Basic horizontal split
+ * <SplitPane direction="horizontal">
+ *   <Pane minSize="200px" defaultSize="300px">
+ *     <Sidebar />
+ *   </Pane>
+ *   <Pane>
+ *     <MainContent />
+ *   </Pane>
+ * </SplitPane>
+ *
+ * // Controlled mode with state
+ * const [sizes, setSizes] = useState([300, 500]);
+ * <SplitPane onResize={setSizes}>
+ *   <Pane size={sizes[0]}>Left</Pane>
+ *   <Pane size={sizes[1]}>Right</Pane>
+ * </SplitPane>
+ * ```
+ */
+export declare function SplitPane(props: SplitPaneProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SplitPane.d.ts.map

package/dist/components/SplitPane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SplitPane.d.ts","sourceRoot":"","sources":["../../src/components/SplitPane.tsx"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAA0B,MAAM,UAAU,CAAC;AAUvE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CA+R9C"}

package/dist/hooks/useKeyboardResize.d.ts

@@ -0,0 +1,34 @@
+import type { Direction, ResizeEvent } from '../types';
+/**
+ * Options for the useKeyboardResize hook.
+ */
+export interface UseKeyboardResizeOptions {
+    direction: Direction;
+    sizes: number[];
+    minSizes: number[];
+    maxSizes: number[];
+    step?: number | undefined;
+    largeStep?: number | undefined;
+    onResize?: ((sizes: number[], event: ResizeEvent) => void) | undefined;
+    onResizeEnd?: ((sizes: number[], event: ResizeEvent) => void) | undefined;
+}
+/**
+ * Hook that handles keyboard-based resizing of panes.
+ *
+ * This is a low-level hook used internally by SplitPane. For most use cases,
+ * you should use the SplitPane component directly.
+ *
+ * Supported keys:
+ * - Arrow keys: Resize by step (default 10px)
+ * - Shift + Arrow: Resize by large step (default 50px)
+ * - Home: Minimize the left/top pane to its minimum size
+ * - End: Maximize the left/top pane to its maximum size
+ * - Escape: Restore pane sizes to what they were when keyboard interaction started
+ *
+ * @param options - Configuration options for keyboard resize
+ * @returns Handler for keyboard events
+ */
+export declare function useKeyboardResize(options: UseKeyboardResizeOptions): {
+    handleKeyDown: (dividerIndex: number) => (e: React.KeyboardEvent) => void;
+};
+//# sourceMappingURL=useKeyboardResize.d.ts.map

package/dist/hooks/useKeyboardResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardResize.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyboardResize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAIvD;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IACvE,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC3E;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB;kCAgBhD,MAAM,SAAS,KAAK,CAAC,aAAa;EAiKpD"}

package/dist/hooks/usePaneSize.d.ts

@@ -0,0 +1,16 @@
+import type { Size } from '../types';
+export interface UsePaneSizeOptions {
+    defaultSize?: Size;
+    size?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+    containerSize: number;
+}
+export interface UsePaneSizeResult {
+    pixelSize: number;
+    minPixelSize: number;
+    maxPixelSize: number;
+    isControlled: boolean;
+}
+export declare function usePaneSize(options: UsePaneSizeOptions): UsePaneSizeResult;
+//# sourceMappingURL=usePaneSize.d.ts.map