react-dockable-desktop 7.2.0 → 7.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md ADDED
@@ -0,0 +1,647 @@
1
+ # Changelog
2
+
3
+ All notable changes to this project will be documented in this file.
4
+ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
5
+ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
6
+
7
+ ## [Unreleased]
8
+
9
+ ## [7.4.0] — 2026-09-30
10
+
11
+ From a consumer's field report: fixed dropdowns inside frosted windows, direction for the sidebar and toasts, translated titles, and a quieter restore.
12
+
13
+ ### Added
14
+ - **Title functions**: a panel, window, drawer or modal title can be `() => string`. It is called each time the title is rendered, so a title built with your own translation function follows a language change (for example `title: () => t('panel.layers')`) — a translated *string* is fixed in the language active when the panel opened. A function isn't saved in a layout: the restored panel takes the title its type is registered with. See [Translated panel titles](https://felipecarrillo100.github.io/react-dockable-desktop/guide/advanced#translated-panel-titles).
15
+ - **`data-rdd-*` identity attributes** on every part of the desktop — `data-rdd-tab`, `-leaf`, `-panel`, `-window`, `-titlebar`, `-taskbar-item`, `-widget` and `-sidebar-tab`, each carrying the id — the scheme vue- and angular-dockable-desktop use. The unprefixed `data-tab-id`, `data-leaf-id`, `data-window-id`, `data-active-panel-id` and `data-cy-action` still render, superseded, and go in 8.0.0.
16
+ - **Reduced motion**: the library's own transitions and animations stop when the user has asked the system for reduced motion (`prefers-reduced-motion: reduce`), as with `animations={false}`. Your own are untouched.
17
+ - The npm package now includes this CHANGELOG.
18
+
19
+ ### Fixed
20
+ - **A `position: fixed` element inside a frosted container was positioned against the container, not the viewport** — so a dropdown, popover or date picker of yours inside a floating window, a drawer, an in-panel widget, a frosted panel toolbar or (in `macos`) a docked panel opened in the wrong place, in some skins and not others. A `backdrop-filter` makes its element the containing block for fixed content; the frost now sits on each container's `::before` (with the background it tints, where the frost saturates). What is drawn is unchanged.
21
+ - **`setDirection('rtl')` did not mirror the sidebar or the toasts**: they followed only `document.documentElement.dir`, so a desktop switched to RTL sat beside an unmirrored rail. They follow the workspace into RTL now, and so does everything inside the sidebar (a toolbar, your own chrome); while the workspace is left-to-right they still follow the page, as before.
22
+ - **A saved window with unusable geometry reached the window's style**: a `NaN` saved as `null`, an `Infinity` or a missing size made React log "`NaN` is an invalid value for the `left` css style property" at every start-up. Such values are replaced on load by the default a new floating window gets, with a development warning naming the window.
23
+
24
+ ### Tests
25
+ - `frost.browser.ts`: a fixed child of each frosted container (7 cases, skins and schemes) lands on the viewport; a screenshot of each matches the pre-7.4.0 rendering within a small tolerance.
26
+ - `motion.browser.ts`, `direction.browser.ts`, `identity.browser.ts`: reduced motion stops every library transition and leaves the page's; the sidebar and toasts follow `setDirection` and still follow the page while LTR; every identity attribute names the right id.
27
+ - Unit: `TitleThunk`, `FiniteGeometry`, `DomAttributes` (no new unprefixed `data-` attribute), `PackageContents` (`npm pack` ships the CHANGELOG), and `StylesheetContract` rules for the frost and reduced motion.
28
+ - The branding and radius baselines compare a frosted container's `::before` as its element: where it is drawn changed, what is drawn did not.
29
+
30
+ ### Docs
31
+ - Theming guide: **Frosted glass and your own overlays**, **Motion**. RTL guide: the sidebar and toasts follow `setDirection`. Advanced guide: **Translated panel titles**, **Finding the desktop's parts from a test**.
32
+
33
+
34
+ ## [7.3.0] — 2026-09-30
35
+
36
+ Branding, part two: your own surfaces and corner shape on any built-in skin. See [Brand your app](https://felipecarrillo100.github.io/react-dockable-desktop/guide/theming#brand-your-app).
37
+
38
+ ### Added
39
+ - **`--rdd-brand-surface`** and **`--rdd-brand-text`**: set per scheme on `:root`, they replace every built-in skin's backgrounds and text — the workspace, panels, tab bar, sidebar, floating windows, modals, drawers, the taskbar, toasts, borders and muted text are all derived from the two. Set both or neither: with only one set, every skin keeps its own surfaces. A skin keeps its shape and effects (macOS's glass, Chrome's tabs, the VS Code accent bar) and each translucent surface keeps the skin's own transparency; the accent, status colours and shadows are not affected.
40
+ - **`--rdd-radius-scale`**: multiplies every corner the library draws — `0` square, `1` each skin's own (the default), `1.5` rounder. Circles and pills stay round. It also scales the radius tokens you set yourself (`--rdd-panel-float-radius`, `--rdd-panel-toolbar-btn-radius`, `--rdd-tab-btn-active-radius`).
41
+ - Theming guide: **Your surfaces** and **Corners** under Brand your app, and the corner habit for custom skins.
42
+
43
+ ### Fixed
44
+ - **`--rdd-brand-on-accent` did not reach the primary button in light mode**, which kept its white text: a light brand colour such as yellow got white text on yellow there. The light-mode rule reads the variable now, default `#ffffff` as before. Found by the angular-dockable-desktop port.
45
+ - **The workspace-edge drop preview was Bootstrap blue** (`#007bff`) in every skin, instead of the skin's accent — the one accent-family literal 7.2.0 missed. It follows `--rdd-accent-color` and `--rdd-brand-accent` now. It shows only while you drag a panel to a workspace edge.
46
+
47
+ ### Tests
48
+ - `radius.browser.ts` (real Chrome, new): the four corner radii of every library element and pseudo-element, in all 7 skins × dark/light, match a 7.2.0 baseline with the scale unset; at `0` every scaled corner is `0px`, at `1.5` every one is 1.5× its baseline, and circles and pills are unchanged.
49
+ - `branding.browser.ts`: with a brand surface set, no background or text colour of any skin's own palette remains anywhere — rendered, hovered or as a token — the workspace, panel and tab bar stay distinct, and text on panels meets 4.5:1 (muted text 3:1), in all 14 scenes; with only one of the two set, a skin renders exactly as unbranded. The 7.1.3 colour baseline still holds with no brand set.
50
+ - `StylesheetContract.test.ts`: every corner length is multiplied by `--rdd-radius-scale`, and the library never declares it; every coloured surface declaration reads a derived value first, which is declared only on `:root` and valid only while both brand inputs are set; no element rule paints a colour of its own, outside status colours and macOS's window buttons.
51
+
52
+ ## [7.2.0] — 2026-09-27
53
+
54
+ Branding: put your company's colour and font on any built-in skin with a few CSS variables — no skin of your own needed. See [Brand your app](https://felipecarrillo100.github.io/react-dockable-desktop/guide/theming#brand-your-app).
55
+
56
+ ### Added
57
+ - **`--rdd-brand-accent`**: set on `:root`, it replaces the accent of every built-in skin in dark and light — tab indicators, active sidebar tabs and toolbar buttons, hover and active tints, glows, the focused window's glow, the taskbar, focus rings, the primary button. Unset, each skin keeps its own accent.
58
+ - **`--rdd-brand-on-accent`**: the text colour on a solid accent fill (the confirmation dialog's primary button, the highlighted dock target), for light brand colours such as yellow. Default `#090b11`, as before.
59
+ - **Per-skin fonts** through `--rdd-skin-font-family`: `vscode` uses VS Code's workbench font, `macos` San Francisco, `chrome` Google's UI fonts, `slate` Fluent's Segoe UI stack, `nord` a humanist sans (Avenir Next) and `tokyo` a monospace (JetBrains Mono); `obsidian` keeps the library stack. All are system font stacks — the library still loads no fonts — and your own `--rdd-font-family` replaces them all.
60
+ - Theming guide: **Brand your app** — the brand variables, a per-scheme brand colour, loading your own font, following a UI framework's theme (Bootstrap, MUI, Angular Material, Tailwind, shadcn/ui), where to put a logo, and how to keep a custom skin brandable.
61
+
62
+ ### Changed
63
+ - **Browser minimum**: CSS `color-mix()` — Chrome / Edge 111, Safari 16.2, Firefox 113 (all 2023). In an older browser the tinted hover and active highlights lose their colour; layout and behaviour are unaffected.
64
+ - **The default skin's font** is VS Code's workbench stack (`-apple-system, BlinkMacSystemFont, 'Segoe WPC', 'Segoe UI', …`) instead of `'Outfit', 'Inter', …`, which is now the fallback for skins that set no font (`obsidian`, and custom skins). If you loaded Outfit for the library, set `--rdd-font-family` to it. In `tokyo` and `nord` the font changes too — and panel content inherits it, so in `tokyo` your panels turn monospace unless they set a font of their own.
65
+ - **Every tint of the accent is derived from it** (`color-mix()` of `--rdd-accent-color`) instead of a hand-copied `rgba()`. With the built-in skins and no brand set, the look is unchanged except for the fixes below.
66
+ - `vscode` light mode has an accent of its own, `#0066cc` — the blue its light-mode tokens already used. The primary button and the taskbar's peek handle, which were cyan on a light background, are that blue now. A custom skin that sets no accent gets it in light mode too.
67
+
68
+ ### Fixed
69
+ - **Overriding `--rdd-accent-color` on `:root` had no effect in 6 of the 7 skins**: each skin redeclared it on the workspace element. The supported way to rebrand is now `--rdd-brand-accent`, which every skin reads first.
70
+ - **Changing the accent left the old colour behind**: 142 hover, active and glow colours were copies of the skin's accent written as fixed `rgba()` values. They follow the accent now.
71
+ - **Skins showed colours that weren't theirs**: the default cyan (and `#0066cc` in light mode) left in other skins — the taskbar hover glow, the dock preview and corner-snap highlights, the floating-widget drop zones, the light-mode focused-tab indicator and taskbar text, the `--rdd-sidebar-card-*` and `--rdd-sidebar-btn-front-*` tokens — now show each skin's own accent. `slate` and `tokyo` drew their active states in a blue that wasn't their accent, and `obsidian`'s panel toolbar in a violet; they use their accent now. `obsidian`'s dark-mode white glows no longer show in light mode, where its accent is black.
72
+
73
+ ### Tests
74
+ - `branding.browser.ts` (real Chrome): with no brand set, the computed colours of every library element, its pseudo-elements, 7 hover states and every token, in all 7 skins × dark/light, match a 7.1.3 baseline — except exactly the fixes above; with a brand set, no trace of any original accent remains; a light brand with a dark on-accent colour is readable on the primary button.
75
+ - `fonts.browser.ts`: each skin's font reaches every piece of chrome, and a brand font set on `:root` wins in every skin, portaled chrome included.
76
+ - `StylesheetContract.test.ts`: every `--rdd-accent-color` reads `--rdd-brand-accent` first, nothing in the library declares a `--rdd-brand-*` variable, no accent colour is written as a literal outside its one declaration, only `:root` declares `--rdd-font-family`, and text on accent fills reads `--rdd-brand-on-accent`.
77
+
78
+ ### Docs
79
+ - A full pass over the README and every guide against the 7.1.3 source. Corrected, among others: `RddDesktop` has no `contextMenuAdapter` prop (it is on the provider); the colour scheme is the `data-color-scheme` your app sets on `<html>` — the library doesn't detect the system preference; `dir` on `<html>` doesn't make the workspace RTL (set it on the provider), and only the sidebar and toasts follow the page's `dir`; `openPanel()` makes the panel active by default; which actions publish `layout:changed`; a modal's default size (`auto`) and a drawer's default width (400px); `{ separator: true }` menu items; the custom resizer sample; the skin selectors for sidebar variables; and the right-click surfaces.
80
+ - Documented: the workspace's title, icon, dirty-state and low-level methods, `requestClosePanel`'s behaviour without `onConfirm`, `DockableDesktopProvider`'s full props and their precedence against `createWorkspace()` config, `registry.get()`/`getRegisteredIds()`, and `ShowContextMenuOptions.dir`.
81
+ - A test (`DocsNames.test.ts`) keeps removed 6.x names and non-existent `RddDesktop` props out of the docs.
82
+
83
+ ## [7.1.3] — 2026-09-25
84
+
85
+ ### Fixed
86
+ - **The autohide taskbar could slide away while the pointer was on it**, so a press there was lost: when a panel was minimized while the pointer was already on the taskbar, and after a quick leave and re-enter (the leave's timer overwrote the pending one without clearing it). Every collapse now replaces the pending timer, and none happens while the pointer is on the taskbar.
87
+ - **RTL: snapping a window to a workspace corner landed on the opposite side.** The corner zones are mirrored by the stylesheet and a window's anchor is drawn mirrored, but the code mirrored the anchor a third time. Floating widgets inside a panel were not affected.
88
+ - **RTL: the active tab had a separator on both sides.** Tab separators are now a logical `border-inline-end`, so every tab state follows the direction by itself.
89
+
90
+ ### Docs
91
+ - `--rdd-font-family`: set it on `:root` or `<body>` to reach everything — menus, the flyout and toasts render into `<body>`, so `initial` (or a stack) on a wrapper reaches only the chrome inside it. The 7.1.1 wording said "any ancestor". Theming guide and the stylesheet comment.
92
+ - `useColorScheme`: its description said the attribute is set by `<RddDesktop />`; it is the page's.
93
+
94
+ ## [7.1.2] — 2026-09-25
95
+
96
+ ### Fixed
97
+ - **Fixed values the library wrote as inline styles couldn't be overridden by host CSS** (an inline style beats every rule without `!important`). They are now in the elements' classes, and inline styles carry only per-render values (sizes, positions, split ratios, scale transforms, state-driven toggles). Moved: the panel's `overflow`/`position`, the tab strip's scrollbar, the tab title's and preview title's max widths, the close buttons' size and end margin, the title-bar button gap, the icons' `display`, the taskbar preview's resting place, the no-preview thumbnail and its letter, the unregistered-panel placeholder, the menus' and search dropdown's `position`, the drawer anchor, and the confirmation dialog's message and divider. New classes: `rdd-workspace-tab-title`, `rdd-close-tab-x--end`, `rdd-svg-icon`, `rdd-taskbar-item-preview-frame--empty`, `rdd-taskbar-item-preview-initial`, `rdd-unregistered-panel__title`, `rdd-unregistered-panel__key`, `rdd-side-panel-anchor`, `rdd-confirmation-message`, `rdd-confirmation-divider`. The look is unchanged — verified by comparing the computed styles of every element in 25 scenes (five configurations, including light, macOS skin, RTL and animations off) before and after.
98
+ - **The unregistered-panel placeholder ignored the colour scheme.** Its border and text use the new `--rdd-danger-color` token (`#dc3545`; `#b91c1c` in light mode — the one intended visual change). The no-preview thumbnail's fill is the new `--rdd-placeholder-bg`.
99
+
100
+ ### Tests
101
+ - A source scan fails on any JSX `style={{…}}` in the library that sets a literal value, so a new fixed inline value can't come back unnoticed.
102
+
103
+ ## [7.1.1] — 2026-09-25
104
+
105
+ Fixes from two consumer issue lists (13 reports, 11 distinct issues).
106
+
107
+ ### Fixed
108
+ - **A click on a minimized panel's taskbar icon was lost** when made within about 150ms of the pointer arriving — even in the icon's centre. The preview fades in over the icon, so the press landed on the preview and the release on the icon. It now fades in from above its resting place, and its hover bridge ends at the icon's top edge instead of covering 4px of it.
109
+ - **Server rendering threw `document is not defined` with any panel open**, and `window is not defined` when a floating panel had been opened before mount. The chrome (tabs, window title bars, taskbar) now renders on the server and panel bodies render on the client after hydration, without a mismatch.
110
+ - **Structural layout is in the stylesheet instead of inline styles**, so host CSS can override it: the workspace root, viewport and grid host, panel and floating-window bodies, the preserved-DOM hosts, the tab bar's height, taskbar items, and the sidebar strip's width (new classes `rdd-workspace-viewport`, `rdd-workspace-grid-host`, `rdd-floating-window-body`, `rdd-panel-dom-host`, `rdd-panel-dom`, `rdd-panel-content`, `rdd-sidebar-strip-wrap--collapsed`). The look is unchanged — verified by comparing the computed styles of every element before and after.
111
+ - **RTL styles follow each element's own direction** (`:dir(rtl)` instead of `[dir="rtl"]` ancestor selectors), so an LTR workspace inside an RTL page is no longer partly mirrored (tab borders, the drop line, the corner snap zones).
112
+ - **Context menus of an RTL workspace inside an LTR page were left-to-right**, so submenus opened on the wrong side. A menu now takes the direction of where it was opened, or the workspace's; the toolbar flyout likewise. `ShowContextMenuOptions` gains an optional `dir`, which a workspace fills in for a menu opened without an event.
113
+ - **Delete on a focused tab dropped keyboard focus to `<body>`.** Focus now moves to the tab selected in its place, or to the workspace's active tab when its group closed too.
114
+ - **The toolbar group flyout had no menu keyboard behaviour.** It now opens with focus on the chosen item; ↑/↓/Home/End move; Esc, Tab or choosing an item closes it and returns focus to the group button.
115
+ - **rdd removed a `data-color-scheme` attribute the page set on `<html>`**, in dark mode and on unmount. It no longer writes that attribute at all: it only ever read it.
116
+ - **Runtime messages used 6.x names** (`<WindowManager />`, `PanelFloatingWindow`); they now say `<RddDesktop />` and `RddFloatingWidget`, and a test keeps removed names out of every message.
117
+ - **`closeLeafGroup` published `layout:changed` when nothing changed** (a tab refused to close). It now publishes only when the group was removed; each closed tab still publishes its own.
118
+
119
+ ### Docs
120
+ - `--rdd-font-family`: to use the page's font, set `inherit` on `:root` or `initial` on any ancestor — `inherit` below `:root` only copies the default stack down (theming guide and the stylesheet comment).
121
+ - RTL guide: direction rules for mixed-direction pages. Advanced guide: server rendering with open panels; the flyout and Delete keys.
122
+
123
+ ## [7.1.0] — 2026-09-25
124
+
125
+ ### Added
126
+ - **Per-panel icons for docked and floating panels.** `usePanel().setIcon(icon)` now changes the panel's tab, floating title bar and taskbar button; until now it only worked in modals and drawers (in 7.0.1 it warned in development). `setIcon(null)` goes back to the registration's `defaultOptions.icon`. Outside the panel, the new `workspace.setPanelIcon(id, icon)` does the same.
127
+ - `PanelInfo.icon`: the runtime icon, readable through `useWorkspaceState`. It is never saved by `saveLayout()`, and `loadLayout()` keeps it for a panel that is still open. Setting the icon a panel already has is a no-op.
128
+
129
+ ### Removed
130
+ - The 7.0.1 development warning for `setIcon` in a docked or floating panel, which now works.
131
+
132
+ ## [7.0.1] — 2026-09-25
133
+
134
+ Fixes found by a consumer migrating a 30-file app from 6.4.0 with the 7.0.0 migration guide, and a revised guide. No API change.
135
+
136
+ ### Fixed
137
+ - **An effect that listed the `usePanel()` handle and wrote the panel's title or dirty flag looped** until React stopped it (`Maximum update depth exceeded`), replacing the panel's body with the error. It is what a mechanical port of a 6.x `[container]` effect produces, and neither `tsc` nor a production build can see it. Two causes, both fixed:
138
+ - the handle got a new identity on every write to the panel. It now changes only when `isActive`, `isMinimized`, `isFloating` or `containerType` does, and its functions (`close`, `minimize`, `setDirty`, `setTitle`, `setIcon`) never change identity — in modals and drawers too, whose container object changes with their title;
139
+ - `setTitle` and `setDirty` wrote a new state even when nothing changed. Writing the title or dirty value a panel, modal or drawer already has is now a no-op.
140
+ - **`usePanel().setDirty(dirty, options)` dropped `options` in docked and floating panels**, so a custom unsaved-changes title or message never reached the close confirmation. Modals and drawers were not affected.
141
+ - **`usePanel().setIcon()` in a docked or floating panel** silently did nothing, while the docs said it changed the tab icon. It still does nothing there — the tab shows the registration's `defaultOptions.icon` — but now warns once in development, and the docs say so.
142
+
143
+ ### Docs
144
+ - Migration guide (§ numbers unchanged): `usePanel()`'s identity contract and a rewrite rule for effects that call `setTitle`/`setDirty` (§3.2, §4.6); a rule for the generic new names (`Workspace`, `usePanel`, `useModals`, …) and a counter-check that no file without this library was changed (§1 rule 10, §6 step 2); the one-hook form for overlays (§4.5); what to do when the app already declares the `html, body, #root` rule (§5.3); a first-render check straight after the compiler (§6 check 1b); install `^7.0.1` (§2); the app's own `var(--sidebar-bg)`-style uses of this library's tokens are renamed too (§5.1); and comments the migration makes false are updated (§1 rule 7).
145
+ - The identity contract in `forms-and-panels.md`, `best-practices.md`, the README and the `PanelHandle` doc comment.
146
+
147
+ ### Tests
148
+ - Regression tests for the handle's identity, the loop (docked, modal, drawer, and in a real browser), no-op writes and the `setDirty` options — each checked to fail with its fix removed.
149
+ - `tests/migration-fixture` now includes the naive port of the 6.x effect.
150
+ - A layout written by `saveLayout()` running the 6.4.0 source is kept as a fixture, and must restore — and save back — unchanged.
151
+
152
+ ## [7.0.0] — 2026-09-25
153
+
154
+ A clean break: the public API takes the names the Vue and Angular ports of this library use, the workspace becomes a store that is live before anything mounts, and the stylesheet stops styling the host page. Nothing is deprecated first — every old name is gone, so the TypeScript compiler finds every call site. **Migration guide: [docs-site/guide/migration.md](docs-site/guide/migration.md#v6-x-→-v7-0-0)** — written so it can be applied by an automated agent in one pass; this release was accepted by having an agent migrate the four demo apps and a fixture app with the guide alone.
155
+
156
+ ### Breaking
157
+ - **React 18 or later.** The peer range said 16.8; the library already relied on React 18 APIs.
158
+ - **`createWorkspace()` replaces `new WorkspaceClient()`.** The workspace is a store that exists on its own: calls made before a `<DockableDesktopProvider>` mounts apply immediately (the queue and `_connect()` are gone). `<DockableDesktopProvider workspace={…}>` replaces `client={…}`; `messages` replaces `predefinedMessages`, in the workspace config and on the provider.
159
+ - **Components carry an `Rdd` prefix**, so they can't collide with a UI kit's own `Toolbar`, `Sidebar` or `ContextMenu`: `RddDesktop`, `RddSidebar`, `RddSecondarySidebar`, `RddToolbar`, `RddModals`, `RddToasts`, `RddConfirm`, `RddPanelOverlay`, `RddPanelToolbar`, `RddToolbarButton`/`Toggle`/`Search`/`Separator`/`Item`/`Spacer`/`Center`, `RddFloatingWidget` (the widget inside a panel — "window" now means only the workspace's floating windows).
160
+ - **Merged components:** `RddSidePanels side="left" | "right"` replaces `SidePanelRenderer`, `LeftPanelRenderer` and `RightPanelRenderer`; `RddContextMenu` replaces `ContextMenuProvider` and the standalone `ContextMenu`.
161
+ - **One provider.** `DockableDesktopProvider` is the only one exported; `WindowManagerProvider`, `PanelProvider`, `ToolbarProvider`, `PanelContributionProvider` and `ContextMenuProvider` are internal.
162
+ - **Hooks:** `useWorkspace()` (actions, registry, events — stable) and `useWorkspaceState(selector)` replace `useWindowManagerActions`, `useWindowManagerState`, `useRegistry` and `usePanelContext`. `usePanel()` replaces `useFormContainer()` and `usePanelId()`; its lifecycle subscriptions become hooks — `usePanelEvents({…})`, `useBeforeClose(guard)`, `useSaveState(fn)` — that clean up by themselves. `useModals()` and `useSidePanels()` replace `usePanelActions()` / `usePanelState()`. Renamed: `useContextMenu`, `useActiveContribution`, `useFloatingWidgets`, `useMessages`, `useHostClasses`, `sectionToTab`, `defaultMessages`. `usePanelFloatingWindow` is removed (a `useState` does the same).
163
+ - **The global `PanelRegistry` singleton is removed.** `PanelRegistry` is now the class; register panels through `createWorkspace({ panels })` or `workspace.registry`.
164
+ - **Types renamed** to match: `Workspace`, `WorkspaceConfig`, `WorkspaceState`, `WorkspaceActions`, `BuiltInEvents`, `PanelHandle`, `OverlayInstance`, `OverlayState`, `OverlayId`, `MessageKey`, `MessageDescriptor`, `HostClasses`, `ManagedWidget`, `FloatingWidgetsApi`, the `Rdd*Props` types and more. `PanelState` now means a panel's own state (`'docked' | 'floating' | 'minimized'`).
165
+ - **CSS:** the 36 remaining unprefixed custom properties are `--rdd-*` (`--sidebar-bg` → `--rdd-sidebar-bg`, …); the skin attribute is `data-rdd-skin` (was `data-workspace-skin`). **The stylesheet no longer styles `html`, `body` and `#root`** — it used to fix them to 100% height with `overflow: hidden`, which stopped any host page from scrolling. A full-window app adds the new `.rdd-fill-viewport` class to its wrapper (or keeps the old rule in its own CSS); a development warning names the fix when the workspace outgrows the window.
166
+
167
+ ### Unchanged
168
+ Every workspace action (`openPanel`, `dockPanelToGroup`, `closeLeafGroup`, …), every domain type (`LayoutNode`, `PanelInfo`, `ToolbarItem`, …), `toast()`, every CSS class name, and the saved-layout format — layouts saved by 6.x load unchanged.
169
+
170
+ ### Tests
171
+ - `api-surface.json` pins every runtime and type export; `ApiSurface.test.ts` fails on any unplanned change.
172
+ - `tests/migration-fixture` — a 6.x app migrated with the guide alone — keeps type-checking and passing its own test against the current API.
173
+
174
+ ## [6.4.0] — 2026-09-25
175
+
176
+ Keyboard and screen-reader access, right-to-left layouts that follow the pointer, and the browser state a panel used to lose when it moved — the remaining defects from the Vue and Angular ports' reports. No API is removed or renamed; a few things are visible and listed under **Upgrade notes**.
177
+
178
+ ### Fixed
179
+ - **Panels lost their scroll position and focus on every move.** A panel's DOM is moved rather than remounted (tab switch, float, dock, minimize/restore), and a detached subtree loses its scroll offsets and its focused element. Both are now recorded while the panel is on screen and put back when it reappears. Focus comes back only for the active panel, and only if it wasn't moved elsewhere in the meantime — a panel restored in the background never takes it.
180
+ - **Right-to-left** — each of these went the wrong way, and each now reads the direction the browser computes, so it works whether `dir="rtl"` is on `<html>`, `<body>`, a wrapper, or set with `setDirection`:
181
+ - a split divider moved away from the pointer;
182
+ - dragging the sidebar drawer's resizer away from its edge shrank it;
183
+ - a toolbar flyout opened on top of its own strip when `dir` wasn't on `<html>`;
184
+ - a context sub-menu landed far from its menu (and, in LTR near the right edge, on top of it — it now flips side when there is no room);
185
+ - a dragged tab landed on the opposite side of the tab under the pointer;
186
+ - the tab-strip scroll buttons showed on the wrong side and scrolled the wrong way.
187
+ - **Resize handles were half clipped.** A floating window's (and an inner floating widget's) `overflow: hidden` cut off the outer half of every edge handle and the corners, so a drag starting just outside the edge did nothing. Clipping moved to an inner frame; the handles straddle the edge in full.
188
+ - **The auto-hide taskbar could disappear under a floating window** parked at the bottom of the workspace. It now stacks above floating windows (and below every popup and overlay).
189
+ - **Stacking ignored `zIndexBase`** for the taskbar preview (a fixed `999999`) and the dragged-tab ghost (`100000`). Both now shift with it, like the rest of the chrome.
190
+ - **Server rendering threw `document is not defined`** from `<WindowManager>` (its colour-scheme reader) and `<ToastContainer>` (its portal). The chrome now renders on the server and hydrates without a mismatch; `useColorScheme()` reports `'dark'` there.
191
+ - **Keyboard access.** Tabs are a WAI-ARIA tab list (←/→, Home/End, Delete to close, one tab stop per group); the context menu is a WAI-ARIA menu (focus on open, ↑/↓/Home/End, sub-menus by key and by click or tap, focus returned on close); taskbar items are buttons; ContextMenu and Shift+F10 open a tab's or taskbar item's menu. Library controls show a focus ring when reached from the keyboard — the toolbar and sidebar buttons suppressed it.
192
+ - **ARIA roles.** Toolbar flyout items are `menuitemradio` (not `menuitem` + `aria-pressed`); checkbox menu items are `menuitemcheckbox`; the toast container is a labelled `region` instead of a live region wrapping live regions.
193
+ - **English leaked into localised apps.** Accessible names and placeholders that bypassed the message table — the toast region and close button, the sidebar drawer close, the panel search box, the tab and taskbar scroll buttons, "More actions", the default modal title, the empty-group and unregistered-component placeholders — now go through it.
194
+ - **Three font stacks, and the host page's font in the toolbar and sidebar.** All chrome now uses one token (below).
195
+
196
+ ### Added
197
+ - `--rdd-font-family` and `--rdd-font-family-mono` — set the chrome's fonts in one place; `--rdd-font-family: inherit` uses the page's font.
198
+ - `--rdd-focus-ring` — the keyboard focus ring (`2px solid var(--rdd-accent-color)`).
199
+ - `data-rdd-preview-unscale` — put it on the container of a canvas-rendered view (a WebGL map) so it renders at full resolution in the taskbar preview.
200
+ - `isComputedRtl(el)` and `isElementRtl(el)` exports. (`isElementRtl` was documented but not exported.)
201
+ - Message keys: `notifications`, `closeNotification`, `scrollTabsLeft`, `scrollTabsRight`, `scrollTaskbarLeft`, `scrollTaskbarRight`, `moreActions`, `search`, `closeSearch`, `searchPlaceholder`, `modalTitle`, `emptyGroup`, `emptyGrid`, `componentUnregistered`, `componentKey`, `untitledPanel`.
202
+
203
+ ### Upgrade notes
204
+ - **`.luciad` is no longer in the stylesheet.** A product-specific class never belonged in the library; it was only used by the LuciadRIA demo apps. If your panel content used `class="… luciad"` for the taskbar-preview counter-scale, use `data-rdd-preview-unscale` instead.
205
+ - **A typed message table gains keys.** A table declared as `Record<PredefinedMessageKey, string>` must add the new keys above (a compile error until it does). Partial overrides are unaffected.
206
+ - **The floating window has an inner frame.** Title bar and body are now inside `.rdd-floating-window-frame` (and an inner widget's inside `.rdd-panel-float__frame`). CSS that relied on them being *direct* children of `.rdd-floating-window` / `.rdd-panel-float` needs a descendant selector.
207
+ - **Layout moved from inline styles into classes** — the split grid (`.rdd-split`, `.rdd-split--row`/`--column`, `.rdd-split-child`), resizer bars (`.rdd-resizer-bar--vertical`/`--horizontal`) and the sidebar (`.rdd-sidebar-layout`, `.rdd-sidebar-content`, `.rdd-sidebar-strip-wrap`, `.rdd-sidebar-pane`). Rendering is unchanged, but your CSS can now override these where inline styles used to win. Rules matching resizer bars by their inline style (`[style*="cursor: col-resize"]`) no longer match; use the orientation classes.
208
+ - **Tabs, taskbar items and context-menu items now take keyboard focus**, and a context menu moves focus into itself when it opens.
209
+ - **`<ToastContainer>` renders on the first client render after mount** rather than immediately (nothing is rendered on the server).
210
+
211
+ ### Tests
212
+ - A real-browser suite: `npm run test:browser` drives Google Chrome (through the new `playwright-core` dev dependency) against a harness page, for everything jsdom can't see — layout, stacking, focus, scrolling, RTL geometry and the Tab order.
213
+
214
+ ## [6.3.2] — 2026-09-25
215
+
216
+ Fixes from defect reports filed by the Vue and Angular ports of this library, each reproduced against 6.3.1 before it was fixed. No API is removed or renamed.
217
+
218
+ ### Fixed
219
+ - **Dark mode left the Toolbar and Sidebar unstyled.** Their colours come from `--sidebar-*` / `--tab-*` / `--toolbar-*`, which were defined only under `[data-color-scheme="dark"]`. `<Toolbar>` and `<Sidebar>` sit outside the workspace element, and `WindowManager` mirrors only a *light* scheme onto `<html>` — so unless the app set `data-color-scheme="dark"` on `<html>` itself, both rendered with no background, border or text colour in the default scheme. The dark tokens are now also defined on `:root`. (The demo apps set the attribute themselves, which is why this went unseen.)
220
+
221
+ - **The active panel went stale after placement actions.** `floatPanel`, `dockPanel`, `dockPanelToGroup`, `dockPanelToWorkspaceEdge` and `movePanelOrder` changed which tab a group showed without updating `activePanelId` — often leaving it on a tab the move had just hidden. The visible tab then rendered unfocused, and `useActivePanelContribution()` kept serving the hidden panel's toolbar controls. Reachable from the UI: drag-reordering a tab that wasn't selected did it. The moved panel now becomes the active one.
222
+
223
+ - **"Maximize Panel" on a minimized panel did nothing.** The taskbar menu offers it, but `maximizePanel` only knew about floating windows. It now restores the panel and maximizes it — floating a panel that was minimized from a group first. For a `canDrag: false` panel minimized from a group, which can't float, the menu no longer offers the item.
224
+
225
+ - **`openPanel` on a minimized panel restored it to the wrong place, silently.** It re-placed the panel from the registry's initial target — the first group, or the default floating position — rather than where it was minimized from, and published no events, so an autosave keyed on `layout:changed` missed the change. It now does exactly what `restorePanel` does (same place, `panel:restored` + `layout:changed`); an explicit `initialTarget` still wins.
226
+
227
+ - **`closeLeafGroup` on a group with panels left them open in no group.** The panels stayed "open" but rendered nowhere. Closing a group now closes each of its panels through the same guarded path as the tab's own × — a close guard can refuse, and a dirty panel stays unless the new `onConfirm` option approves — then removes the group once it is empty. A panel that refuses keeps its group.
228
+
229
+ - **One Escape could close several overlays at once.** Each overlay listened on `document` separately, and `stopPropagation()` doesn't stop other listeners on the same node: one Escape closed both side drawers, or a context menu *and* the modal under it, or the panel search box *and* the drawer holding it. Escape now closes exactly one overlay — the one on top: context menus and toolbar flyouts above modals, modals above drawers, and the most recently opened within each. A control that handles Escape itself can keep its overlay open by calling `preventDefault()`.
230
+
231
+ - **A maximized floating window kept its rounded corners, border and shadow.** The rule targeted `.maximized`; the component emits `rdd-maximized`.
232
+
233
+ - **A hidden toolbar left a 1px line and stayed in the Tab order.** `visible={false}` collapsed the strip to 0 but its edge border still painted, and keyboard focus landed on buttons nobody could see. A hidden strip now has no border or padding, and is `inert` and `aria-hidden`.
234
+
235
+ - **The documented `interface AppEvents` event map failed to compile** (`TS2344`) with `new WorkspaceClient<AppEvents>()`: the type parameter was constrained to `Record<string, unknown>`, which an interface doesn't satisfy. It is now constrained to `object`; payloads are still checked.
236
+
237
+ - **The context menu's outside-click check threw** for a click dispatched on `window` itself (not a DOM node). It now closes the menu.
238
+
239
+ ### Changed
240
+ - **`closeLeafGroup(leafId, options?)` returns a `Promise<void>`** that settles once every close request has, and accepts `{ onConfirm }` for dirty panels (see above). Source-compatible: code that ignored the old `void` return is unaffected.
241
+ - **Placement actions publish `layout:changed`.** `floatPanel`, `dockPanel`, `dockPanelToGroup`, `dockPanelToWorkspaceEdge`, `movePanelOrder`, `closeLeafGroup`, and maximizing a minimized panel now each publish it once. The event is documented as "the layout changed", and autosave depends on it — expect autosave handlers to run on these actions from now on.
242
+ - **Six `@keyframes` are now `rdd-` prefixed** (`rdd-fade-in`, `rdd-scale-up`, `rdd-slide-in-left`, `rdd-slide-in-right`, `rdd-tooltip-fade-in`, `rdd-toolbar-flyout-in`). Keyframe names are global to the page, so a host stylesheet defining its own `fadeIn` (Animate.css and many themes do) silently replaced the library's animation.
243
+ - **Demo-only CSS no longer ships in `styles.css`.** The `.sb-*` sidebar-builder rules, `.full-viewport-layout` and `.hover-bg` belong to the demo apps (the docs already said they are not library API) and moved to `demo/demo-shared.css`. Unused rules were deleted (`.desktop-workspace`, `.window-manager-workspace`, `.sidebar-window-card`, `.btn-pill-outline`, `.badge-pill-dark`, `.sidebar-card-title`, `.rdd-scrollbar-hidden`, `.rdd-panel-float__resize`). If an app used any of these classes from `styles.css`, copy the rule from `demo/demo-shared.css`.
244
+
245
+ ### Added
246
+ - **A `LICENSE` file (MIT) and a `license` field in `package.json`.** The README always said MIT, but the published package carried no license text and npm showed no license for it.
247
+
248
+ ### Tests
249
+ - `StylesheetContract.test.ts` reads `index.css` as text and fails on an unprefixed class, keyframe or custom property, an `animation` naming no defined keyframes, or a rule for a class no component emits — the three kinds of stylesheet defect above, none of which a jsdom rendering test can see.
250
+
251
+ ## [6.3.1] — 2026-09-19
252
+
253
+ ### Fixed
254
+ - **Dragging the only docked panel onto its own group duplicated it.** With one panel in the workspace, dropping it on its own drop cross — any direction — left the same panel in *two* groups: two tabs with the same title, one of which showed nothing at all, since a panel's DOM can only live in one slot. Dropping it on the workspace edge did the same. Reported against 6.2.0 and reproduced in 6.3.0.
255
+
256
+ The cause is one `||`. `removePanelFromTree` returns `null` to mean *"this node should disappear"*, which at the root means the workspace is now empty; `cleanRoot || prev.gridRoot` read that `null` as *"nothing was removed"* and ran the split against the tree that still contained the panel. The idiom appeared in four reducers — `dockPanel`, `dockPanelToGroup`, `dockPanelToWorkspaceEdge`, `movePanelOrder` — and each now falls back to an empty grid, which is what `null` actually means. `movePanelOrder` and the centre zone were harmless only by accident: their re-insertion happened to cancel the duplicate out.
257
+
258
+ Above that fix sits the rule the gesture was asking for all along: **dropping a lone panel onto its own group is a no-op**, because the result would be the layout it already has. Removing the panel first deletes the emptied group, so the drop destroyed the very target it named — the shape of the whole defect. Guarded in the reducers rather than in the drag layer, so `WorkspaceClient` and the actions API are covered too, not just the mouse.
259
+
260
+ - **A dock into a group that no longer exists lost the panel.** Emptying a group removes it, so an id an application held across a layout change can name a group that is gone; placing into it stripped the panel from the layout and left it "open" but in no group — rendered nowhere, and recoverable only by minimizing and restoring it. `dockPanelToGroup` and `movePanelOrder` now ignore such a call (with a development warning), and `dockPanel` falls back to the first real group, since its caller asked for the panel to be docked *somewhere*.
261
+
262
+ - **Layouts already saved with the duplicate are repaired when read.** `saveLayout()` wrote the duplicated tree out, so the fault came back on every reload — a stored layout stayed broken for good. `loadLayout()` and `initialState` now share a repair pass: a panel id listed in more than one group is kept in the first, a group emptied by that is dropped unless it set `keepOnEmpty`, a branch left with one child collapses, and a panel the layout calls docked but that no group lists is put back into the first group. One development warning names what was repaired. This changes only what is *read* — `saveLayout()`'s format is untouched — so saving again from a repaired session simply stores the corrected layout.
263
+
264
+ Covered by a new `SelfDrop.test.tsx`: 20 tests over the five drop positions, the workspace edge, the tab strip, the stale-target cases, the two-panel cases that must still split and reorder, and both repairs. Each was mutation-checked, and the whole gesture set was re-run in Chrome against the fixed build.
265
+
266
+ ## [6.3.0] — 2026-09-16
267
+
268
+ ### Added
269
+ - **An inner floating widget's title can now be an i18n message descriptor, so a float's header follows a language change.** `ManagedWindowConfig.title` and `PanelFloatingWindowProps.title` were declared `string`, while every other title surface in the library — `OpenPanelOptions.title`, `ModalOptions.title`, `SidePanelOptions.title`, panel tabs, context menus — already accepted `PanelTitle` (`string | PanelTitleDescriptor`) and already re-resolved it. Both float surfaces now take `PanelTitle` too, resolved at the header's render site with the library's own `formatLabel(title, useFormatMessage())`.
270
+
271
+ The managed path is where this was a real defect rather than an inconsistency: `usePanelFloatingWindowManager().open(id, config)` **stores** the config, so a plain string is frozen at whatever language was active when the widget opened, and the only way to change it was to re-call `open()` for every open ID from a locale effect. A descriptor needs none of that. The declarative `PanelFloatingWindow` is a prop in the host's own JSX and so already updated on re-render; it is widened here so the two paths agree.
272
+
273
+ Nothing breaks: `PanelTitle` includes `string`, and `formatLabel` passes a plain string through untouched, so every existing `title: "…"` compiles and behaves exactly as before. Reported against 6.2.0 with the mechanism already correctly located — the capability was reachable everywhere except here.
274
+
275
+ One limit worth knowing, unchanged by this release: `ManagedWindowConfig.content` is a React element captured when `open()` was called, and its props never change afterwards. A body that must follow the language has to read the locale itself rather than receive already-translated text from the call site. Documented in the [Panel Overlay guide](https://felipecarrillo100.github.io/react-dockable-desktop/guide/panel-overlay#localised-titles).
276
+
277
+ ### Fixed
278
+ - **An inner floating widget's close button had a hardcoded English tooltip.** Its `title` and `aria-label` were the literal string `"Close"`, ignoring the `closeTooltip` entry that has been in `defaultPredefinedMessages` all along — so a fully localised workspace still exposed one English string, to screen readers included. It now resolves through the catalogue like every other control. No new message keys, and no change for anyone who has not overridden `closeTooltip`. `PanelOverlay.tsx` was the only file in the library that never called `formatLabel`/`useFormatMessage`; it isn't any more.
279
+
280
+ ## [6.1.0] — 2026-09-11
281
+
282
+ ### Added
283
+ - **`PanelFloatingWindow` can now span its host panel on either axis, tracking it as it resizes.** Previously an inner widget could anchor to one of four corners with a fixed width and height; there was no way to say "anchored to the bottom, full width" — the shape a timeline or status strip wants. The demo already faked it one layer up, where the workspace-level `timecontrol` panel resorts to `favoritePosition: { x: '10px', width: 'calc(100% - 20px)' }`.
284
+
285
+ The mechanism is that "full width" isn't a width, it's a **second pin**: a stretched axis sets *both* insets and writes no size at all, so CSS keeps the widget spanning the panel with no `ResizeObserver` and no JavaScript. Each axis is independently pinned-at-one-end or stretched, giving nine placements of which the four existing corners are four; height is not a second feature but the same mechanism on the other axis. `size` is deliberately never overwritten while an axis is stretched — the same trick a maximized floating window uses to keep its rect — so releasing an axis restores the size it had before, with no snapshot and no bookkeeping.
286
+
287
+ New props on `PanelFloatingWindow`, plus the matching `stretch` field on `ManagedWindowConfig` for `usePanelFloatingWindowManager().open()`: **`defaultStretch`** (`'width' | 'height' | 'both'`, uncontrolled), **`stretch`** (controlled — supplying it, *including as `null`*, makes the caller the single source of truth, matching `ToolbarToggleItem.active` and `Sidebar.activeTabId`), **`onPlacementChange`**, and **`stretchable`** (`false` opts a widget out of snapping). New exported types: `Stretch` and `PanelFloatPlacement`. Placement is reported as one atomic `{ anchor, stretch }` pair rather than two callbacks, because a single gesture can change both — dragging a full-width strip's left end pins the right one and un-stretches in the same motion — and separate reports would surface a state that is never valid. Controlled mode is also the route to persistence: the library serialises nothing about inner widgets, so store what `onPlacementChange` gives you and feed it back.
288
+ - **Resize an edge out to the far extent and the axis snaps to stretched.** Dragging a free edge until it reaches where a stretched axis would sit converts it on release, so full-width is reachable by direct manipulation rather than only declaratively. Arming is deliberately asymmetric — within 16px of the extent to arm, but 40px of pull-back to release — because without that hysteresis, un-stretching an axis by dragging slightly inward would re-arm and snap straight back, which makes the gesture feel broken. The cue is a dashed accent outline (`.rdd-panel-float--snapping`, the same visual vocabulary as the corner drop zones) rather than a ghost preview, because the resize clamp now lands exactly where the stretched axis sits, so an armed drag is already at its target. On commit the axis restores the size it held *before* the drag, not the full-bleed value the drag passed through, so releasing it later returns the size you last chose deliberately.
289
+ - **A stretched axis can always be released by dragging either of its ends**, on the principle that *the edge you grab is the edge that moves, and the opposite end becomes the pin*. That is what keeps stretch from being a one-way trap: since 6.0.1 a docked widget only renders handles on its *free* edges, and an axis with both ends pinned has none — so a stretched axis now renders handles on both of its ends, and the fills-the-panel state has all four edges live rather than nothing to grab. Releasing one axis of `'both'` leaves the other stretched. Corner handles appear only in the all-pinned state, where they don't mix a resize with a release.
290
+ - **Stacking understands strips.** The four corner buckets were always a proxy for *"do these overlap on the inline axis?"* — two widgets in one corner overlap and stack, opposite corners sit side by side. A full-width strip overlaps everything on its edge, so it now occupies **both** buckets of that edge and clears whatever is stacked in either: with a 120px card bottom-left and a 90px card bottom-right, a strip sits at `bottom: 128px`, and neither card moves. A block-stretched widget spans the very axis stacking uses to separate siblings, so it occupies no bucket at all and overlaps by z-order, with a dev-only warning when that combination is declared. Non-stretching widgets stack exactly as before. Computing true inline overlap was considered and rejected: widths change continuously during a resize drag, so widgets would reshuffle mid-gesture.
291
+ - **`PanelOverlayCtx` now exposes `insetInlineStart`/`insetInlineEnd`**, the space claimed by `PanelToolbar`s on the `left`/`right` edges. `registerToolbar` had always recorded them; they were simply never surfaced, so nothing could keep clear of a side toolbar the way the block axis already did. Logical, matching how `PanelToolbar` positions itself.
292
+
293
+ ### Fixed
294
+ - **A plain click on an inner widget's header silently tore it off its anchor.** `handleHeaderPointerDown` called `undockWindow`/`setMode('free')` unconditionally on *pointerdown*, with the 4px drag threshold gating only the drop-zone overlay. Nothing appeared to happen to the clicked widget — its free position was snapshotted to where it already sat — but any siblings stacked in that corner reflowed to close the gap, and the widget stopped tracking its corner on every later panel resize, permanently and one-way. Undocking now happens at the drag threshold, where it belongs; `rdd-dragging-active` moved with it, and a press that never became a drag settles nothing. This also had to be fixed before the stretch work above, since otherwise clicking a full-width strip's header would convert it into a stale-width free box that no longer tracks the panel — destroying the exact property the feature exists to provide.
295
+ - **A docked inner widget could be resized clean over a `PanelToolbar` on the far side.** Growth was bounded by the raw container edge (`maxW: cw - start.x`), so a widget anchored opposite a toolbar could be dragged straight across it. Measured before the fix: a 640px overlay with 49px toolbars top and bottom let a widget grow to 591px in either direction, ending flush against the container edge with the toolbar underneath it. The new `dockedBand()` converts the toolbar insets (now including the inline ones) from logical to physical and bounds docked resizing by them; free-floating widgets stay unconstrained, since free means free. The library already treats this as a defect elsewhere — a 5.x fix stopped docked floats *positioning* themselves over a toolbar, but the resize path never got the same treatment. As a bonus the clamp now lands exactly where a stretched axis sits, which is what lets the snap above commit with no visual jump.
296
+ - **Detaching a stretched widget snapped it back to its pre-stretch size.** Free mode positions from an explicit box, and a stretched axis carries no size, so dragging a full-width strip loose would have jumped it to whatever width it had before stretching. Detaching now materialises the measured size first and clears stretch, since "free-floating" and "spanning the panel" are mutually exclusive.
297
+
298
+ ## [6.0.1] — 2026-09-11
299
+
300
+ ### Fixed
301
+ - **Three of the library's own stylesheet rules matched nothing at runtime, because the class the component actually rendered was left unprefixed when the `rdd-` prefix convention was applied to `index.css`.** In each case the CSS was correct and present in the shipped `styles.css`; the JSX simply emitted a name no selector could match, so the rules were dead on arrival with no error anywhere. All three now emit the prefixed name the stylesheet expects. Covered by a new `StyleHookups.test.tsx`, which asserts on the rendered class names rather than computed styles — `index.css` is never loaded under jsdom, so a computed-style assertion would have passed regardless of which class was emitted, which is exactly how this went unnoticed:
302
+ - **`taskbarVisibility="autohide"` had no effect at all** — it rendered as an ordinary permanent taskbar. Every autohide rule is keyed off the compound selector `.rdd-taskbar-footer-container.rdd-taskbar-mode-autohide` (the absolute overlay, the collapse-to-8px transition, the peek-strip reveal, and the coarse-pointer `@media` override), but `WindowManager` emitted `taskbar-mode-autohide`, so none of them applied. The sibling `rdd-taskbar-expanded` class was always correct, yet inert on its own for the same reason — all of its rules are compounded with the missing one. `'always'` and `'compact'` are unaffected either way: neither has any mode-specific CSS.
303
+ - **`DirtyStateOptions.alert`'s banner never showed its severity colour.** `.rdd-confirmation-alert-danger`/`-info`/`-warning`/`-success` supply the background, border, and text colour per `alertType`, but `ConfirmationForm` emitted `confirmation-alert-${alertType}`, leaving only the base `.rdd-confirmation-alert` layout rule in effect — so every banner rendered unstyled and identical regardless of `alertType`, including in the library's own unsaved-changes dialogs, which pass `alertType: 'danger'`.
304
+ - **`zIndexBase` silently did not move the context menu or the panel-overlay search dropdown**, despite both being listed in its own documentation as shifting together via `--rdd-z-base`. `.rdd-context-menu` and `.rdd-context-menu--submenu` already carried `calc(var(--rdd-z-base, 1000) + 8500 / + 8501)`, but `ContextMenu` also set `zIndex: 9500`/`9501` inline, which always wins over a stylesheet declaration — so the menu stayed pinned at its default stacking no matter what a consumer configured. Both inline values are removed, leaving the existing CSS in charge. `ToolbarSearchInput`'s portaled results dropdown had the same inline `9502` with no corresponding rule at all; it now gets `.rdd-panel-toolbar-search__dropdown { z-index: calc(var(--rdd-z-base, 1000) + 8502) }` instead. **This changes nothing at the default configuration** — `--rdd-z-base` defaults to `1000`, so the three now resolve to exactly the 9500/9501/9502 they were hardcoded to, including when a `ContextMenuProvider` is used standalone with no `WindowManagerProvider` mounted to write the variable (the `var(..., 1000)` fallback covers that). A caller-supplied `style={{ zIndex }}` on `ContextMenu` keeps overriding it, as before — that spread still comes last.
305
+ - **Restoring a layout activated the wrong panel.** `state.activePanelId` was seeded from `Object.keys(panels)[0]` — the first key of a flat, insertion-ordered record that carries no notion of tab order or of docked/floating/minimized — so unless the user happened to have the first-opened panel selected when they saved, the workspace came back with one panel **visible** and a different, **invisible** one marked active. Everything keyed on `activePanelId` was then misrouted for the whole session, until the user next clicked inside a panel: `useActivePanelContribution()` and therefore every sidebar tab and toolbar item published through `usePanelContribution()`, the `onActivate`/`onDeactivate` lifecycle hooks, and the focused/unfocused tab and window chrome (the visibly selected tab even rendered as *unfocused*). The failure was silent in the worst way — because panels are never unmounted, a hidden panel's contribution really does publish and its controls really do respond, so they looked functional while acting on a panel nobody could see. The information needed was already on disk and simply never consulted: every `LayoutLeafNode` persists its own `activePanelId`. Fixed in one shared place — `parseLayoutPayload`, which both entry points already go through — since the identical seed existed **twice**, in `initialState` hydration *and* in `loadLayout()`, so a fix in either alone would have left the other broken. The restore now resolves, in order: the snapshot's own newly-persisted `activePanelId` when it still names a visible panel; else the selected tab of the first leaf in the grid, depth-first (a breadth-first walk reaches a later sibling's leaf before the first leaf's own children, and picks the wrong tab in a nested grid); else the frontmost floating window, so float-only layouts don't restore with nothing active; else `null` — never an arbitrary entry in `panels`.
306
+ - **`saveLayout()` now records the active panel** as a new optional `SerializedLayout.activePanelId`, which removes the remaining guesswork for layouts with more than one leaf — *which* leaf held focus was not recoverable from the grid alone. Emitted only when it survives the same serializability pruning as everything else, so it never names a panel missing from its own snapshot, and omitted entirely when nothing is active. Fully additive in both directions: `version` stays at `2` (the field's absence is a supported, fully-handled case, not something a migration has to branch on), older layouts simply take the derivation path above, and an older library reading a newer layout ignores the field, since the parser whitelists what it reads.
307
+ - **Closing or minimizing the active panel left `activePanelId` behind on it** — the same class of bug as the restore above, reachable without ever calling `saveLayout()`. Closing it left the id pointing at a deleted panel; minimizing it left an off-screen panel globally active while still mounted, so its contributed controls kept working on something the user could no longer see. Both now re-resolve to whatever became visible in its place, through the same derivation the restore uses. **Behavior note:** minimizing the active panel consequently fires `onDeactivate` for it and `onActivate` for its replacement, neither of which fired on minimize before. An explicit `focusPanel()` on a minimized panel is still honoured as-is — that's a deliberate caller decision, so it is left alone.
308
+ - **A corner-anchored `PanelFloatingWindow` offered its resize handles on the wrong edges.** A docked inner panel has one pinned edge per axis — `top-*` pins `top`, `bottom-*` pins `bottom`, `*-left` pins `insetInlineStart`, `*-right` pins `insetInlineEnd` — but the handle set was hardcoded to the five non-northern directions regardless of anchor, with only `n`/`ne`/`nw` gated behind free-floating mode. Dragging a handle on a *pinned* side moves the opposite edge rather than the one under the cursor, and `computeResizedRect`'s bounds stop it at that side's own inset, so it was an inert stub wearing a resize cursor. For top anchors this was merely redundant (the correct handle was rendered too), but **a bottom-anchored window had no working vertical resize at all**: `n` was never rendered, and `s` — its only vertical handle — was the stub. With no bottom toolbar its `maxH` evaluated to exactly its current height, making the window a one-way ratchet: shrinkable, never re-growable. The same flaw existed on the inline axis and went unnoticed only because both `e` and `w` were always rendered, so the working one was always present. A docked window now renders exactly the handles on its free edges — one per axis plus their shared corner (e.g. `n`/`w`/`nw` for `bottom-right`) — which also mirrors correctly under RTL, where the pin is a logical property (`insetInlineEnd`) but the handle classes are physical (`.rdd-resize-e`). No change to the resize math was needed: restricting the set to free edges leaves every remaining direction already correctly bounded, since `maxW`/`maxH` apply only to eastward/southward growth while `minX`/`minY` bound the moving edge for the westward/northward case. Free-floating windows still offer all eight handles, and `WindowManager`'s own floating windows are untouched. **Behavior note:** a docked inner panel now shows three handles where it previously showed five; the two that disappear are the pinned-side stubs that could never move an edge by more than 8px.
309
+
310
+ ## [6.0.0] — 2026-08-29
311
+
312
+ ### Changed
313
+ - **BREAKING: `.rdd-side-panel-body`'s and `.rdd-modal-body`'s default padding both changed from `10px` to `0`.** A docking library's job is layout mechanics, not content styling — padding is a decision that belongs entirely to whoever fills the panel or modal, and the old fixed value sat at the wrong layer once content needed its own internal scroll+footer layout. Any `openLeftPanel`/`openRightPanel`/`openModal` content relying on that outer spacing now renders edge-to-edge; restore the old look with the new `bodyPadding` option (below) — `{ bodyPadding: 10 }`. See the [Migration Guide](https://felipecarrillo100.github.io/react-dockable-desktop/guide/migration) for the full upgrade note.
314
+
315
+ ### Added
316
+ - **`SidePanelOptions.bodyPadding` and `ModalOptions.bodyPadding`** (both `number | string`) — CSS padding for the panel/modal body, e.g. `12` (pixels) or `'10px 16px'` (any CSS shorthand). Applied the same way `SidePanelOptions.width` already is: a per-instance inline-style override on `.rdd-side-panel-body`/`.rdd-modal-body`, passed to `openLeftPanel`/`openRightPanel`/`openModal`'s options. Omitting it (the new default) leaves the panel/modal edge-to-edge; every other option (`title`, `icon`, `width`, `size`, `closable`) is unchanged.
317
+ - **`<SecondarySidebar>`** — a second, independent `Sidebar` instance for the opposite edge of the screen, sharing the exact same implementation (no forked code). Must be rendered inside a primary `Sidebar`'s `children` — it detects the primary via context (which only flows to descendants, so this is a hard structural requirement, not just a recommendation) and always takes whichever side the primary isn't using; `position` isn't settable on it at all. Throws if rendered with no primary ancestor, or if nested inside another `SecondarySidebar` — exactly one primary plus one secondary is supported, nothing deeper. `useSidebar()`'s return value gains two fields, useful independent of `SecondarySidebar` — `position` (`'left' | 'right'`) and `isSecondary` (`boolean`) — so any consumer can tell which instance it's inside. Fully additive: every existing `Sidebar` usage is unaffected. Also includes an internal fix: resizing one sidebar's drawer used to transiently suppress the *other* sidebar's transition too, when nested — the suppression mechanism (previously a DOM class matched via a broad CSS descendant selector) is now driven by each instance's own React state, which can't cross between instances by construction.
318
+
319
+ ### Fixed
320
+ - **`.rdd-sidebar-drawer-body` (the Sidebar tab content area) now gets the same thin scrollbar treatment as the rest of the library.** The existing thin-scrollbar rules were scoped to `.rdd-workspace *` — but `<Sidebar>` is documented to mount as a *sibling* of `<WindowManager>`, not a descendant of `.rdd-workspace`, so none of that styling ever reached it and it fell back to the browser's native scrollbar. Extended the existing rule's selector list to also cover `.rdd-sidebar-drawer-body`, rather than duplicating the thumb/track/radius values in a second rule.
321
+ - **The library's own rendered elements no longer render at an inconsistent size depending on what CSS reset the host app happens to load.** Rules combining `padding` with a fixed or percentage `min-height`/`max-height`/`height` (`.rdd-side-panel-header`, `.rdd-floating-window-titlebar`, both `.rdd-toolbar-strip` orientation rules) never declared their own `box-sizing`, so each rendered differently depending on whether the host page reset `box-sizing` globally (MUI's `CssBaseline`, Bootstrap's reboot) or left the browser default (`content-box`) in effect — same CSS, visibly different size, purely by chance of which app it landed in. Added `[class*="rdd-"] { box-sizing: border-box; }`, targeting the library's own rendered elements directly (never a consumer's own nested content) with no `!important` — its specificity reliably beats an accidental, broad host reset while still losing to a consumer's own deliberate, targeted override.
322
+
323
+ ## [5.4.0] — 2026-08-27
324
+
325
+ ### Added
326
+ - **`SidebarTab` gains an optional `hidden` field** — omit a tab's rail button entirely while it stays fully openable via `openTab()`/`useSidebar().openTab()`/a controlled `activeTabId`, for menu-driven panels with no persistent icon (e.g. a Google-Maps-style hamburger opening a side panel that isn't otherwise pinned to the rail). `icon` widens from required to optional to allow this — existing tabs are unaffected, since every current tab object already supplies one. No other behavior changes: `allTabs`, drawer mounting, the auto-close-when-removed guard, and `stripVisible`/`hideStrip()`/`showStrip()` (which already collapse the whole rail, composing independently with per-tab `hidden`) are unchanged.
327
+ - **`Sidebar` gains two new Sidebar-level props, `hideDefaultHeader` and `renderHeader`** — suppress the library's own drawer header (the tab-label title, and `showCloseButton`'s "X" button, when set) for **every** tab at once, and optionally supply one custom header renderer shared uniformly across all of them, instead of the library's own markup. `renderHeader(tab, onClose, onOpen)` is called once for whichever tab is currently active, so a single implementation (e.g. a search field plus a close button, or a hamburger/label/close row) stands in for the default header everywhere, rather than being duplicated inside every tab's own `renderContent`. The close mechanism needs no new plumbing: `renderContent(tabId, onClose, onOpen)`'s `onClose` parameter and `useSidebarTab().onClose` (readable from anywhere in a tab's content tree) already worked independently of whether the default header rendered, so a custom close button wired to either one, or to `renderHeader`'s own `onClose` parameter, keeps working exactly as before. Passing `renderHeader` is by itself sufficient to suppress the default header — the two props are combined with OR (`hideDefaultHeader || renderHeader != null`), specifically so that supplying `renderHeader` alone is never a silent no-op; `hideDefaultHeader` on its own remains meaningful for the "no header at all, `renderContent` supplies one" case. Implemented as a single render-suppress edit in the one shared drawer-mounting loop used for `tabs`, `headerAction`, and `footerAction` entries alike. Fully additive: both props default to unset/`false`, so every existing `<Sidebar>` (which never sets them) renders its header byte-for-byte as before. `showCloseButton` has no effect once the default header is suppressed by either prop, since the entire default header — button included — is skipped for every tab in that case; a dev-only `console.warn` (stripped outside `NODE_ENV=development`, fires once per mounted `Sidebar`) now flags this combination, matching the existing warning conventions in `WindowManager.tsx`/`WindowManagerContext.tsx`.
328
+ - New permanent `demo-sidebar/` example app (`npm run dev:sidebar`) demonstrating both features together, imitating Google Maps' own UI: no app chrome/bar — the map fills the viewport edge-to-edge — with a floating hamburger button opening a real `openLeftPanel()` side panel containing a "Show side bar" switch and a list of options, each opening a `hidden` tab with no rail icon of its own; toggling the switch reveals an ordinary rail with icon-bearing tabs alongside them. A shared `renderHeader` (a search box plus a close button) replaces the default header uniformly across every tab — "Saved", "Recents", and a new `hidden` "Custom Header Demo" tab alike — the latter reachable only via a plain "Open Custom Header" text trigger (deliberately no icon anywhere, rail or otherwise), plus a hamburger inside the header itself whenever the rail is hidden, so the Menu panel stays reachable in every state.
329
+
330
+ ## [5.3.5] — 2026-08-26
331
+
332
+ ### Fixed
333
+ - **A toast's content that grows after mount — most commonly `toast.promise()`'s short `pending` message being replaced by a longer, wrapped `error`/`success` message — got visually clipped instead of the card growing to fit it.** `ToastItem` locked `max-height` to `offsetHeight` once, in a `useLayoutEffect` with an empty dependency array, purely so the exit-collapse animation has a concrete pixel value to transition from (CSS can't animate `max-height` smoothly from `none`). That lock was never revisited afterward, and `.rdd-toast` has `overflow: hidden`, so any later content taller than the first render got silently cut off. Confirmed live in a browser (`toast.promise()` with a one-line `pending` message and a four-line `error` message): the error text was cut off mid-sentence. Now re-measures via a `ResizeObserver` on the toast's inner `.rdd-toast__body` (the only part of the card whose own box isn't artificially held at a fixed height, so it's the only thing that reliably reports a size change while the outer card is still clipped) and applies the outer card's `scrollHeight` — not `offsetHeight`/`clientHeight`, both of which just reflect whatever stale cap is already in effect — as the new `max-height`. Frozen once the exit animation starts, same as before. No API change.
334
+
335
+ ## [5.3.4] — 2026-08-25
336
+
337
+ ### Fixed
338
+ - **5.3.2 and 5.3.3 did not actually fix the side-panel autofocus scroll-jump bug** — confirmed live in a real browser, not just unit tests, which is how this was caught: `useAnimationScrollGuard` watched `window.scrollX`/`scrollY`, but in a real app `window` never moves. `.rdd-side-panel` used `position: absolute`, so its containing block is whatever `position: relative`/`absolute` ancestor the consuming app happens to have between it and the document — exactly the "mount as a sibling of `WindowManager`" pattern this library documents. While the panel is off-screen mid-slide-in (a `transform`, not a visibility change), it contributes real scrollable overflow to *that ancestor* — the browser auto-scrolls the ancestor on focus and then continuously re-clamps its scroll position in lockstep with the animation as the overflow shrinks, dragging the ancestor's entire visible content (the whole workspace — map, sidebar, everything sharing that scroll box) left/right and back over the full ~250ms, not window/document. No amount of watching `window`'s scroll position could ever catch this. `.rdd-side-panel` now uses `position: fixed`, matching `.rdd-modal-overlay`'s existing (and already-correct) approach — this removes the panel from any ancestor's scrollable-overflow calculation entirely, verified with live-browser instrumentation walking the full ancestor chain: neither `window` nor any ancestor moves at any point during the animation, for both `openLeftPanel` and `openRightPanel`, with a real autofocusing `<input>`. Removed `useAnimationScrollGuard` (added in 5.3.2, reworked in 5.3.3) — it protected the wrong element and is unnecessary now that the actual mechanism is eliminated at the CSS level; the modal path was verified to have never needed it, since `.rdd-modal-overlay` was already `position: fixed`. Kept `preventScroll: true` on the library's two internal `.focus()` calls (`ConfirmationForm`, `PanelOverlay`'s search input) as harmless defense-in-depth.
339
+ - **`position: fixed` alone would have broken apps that don't give the workspace the full browser viewport** — e.g. a layout with an app-level toolbar across the top and the workspace only occupying the area below it. Unlike `position: absolute`, `fixed` always anchors to the true viewport unless an ancestor has `transform`/`filter`/`will-change`, so the side panel would have started sliding in from behind/over that toolbar instead of below it. Added `useContainerRect` (`src/hooks/useContainerRect.ts`), which measures — via `ResizeObserver` plus a `useLayoutEffect` for the initial synchronous read — the actual on-screen rect of the container the app placed `SidePanelRenderer`/`WindowManager` into (found via an always-mounted, zero-footprint `display: contents` anchor, so it works whether or not any panel is currently open), and applies that rect as the panel's `top`/`height`/`left`-or-right instead of the CSS defaults. For a full-viewport app the measured rect equals the viewport, so this is a no-op visually — verified via direct `getBoundingClientRect()` checks (not just screenshots, since z-index can visually mask a wrong position) that the panel still renders identically for the documented full-viewport pattern, correctly docks below an 89px app toolbar in a toolbar-above-workspace layout, and stays correct across a live window resize. No API change — this is fully automatic, nothing for consumers to configure.
340
+
341
+ ## [5.3.3] — 2026-08-25
342
+
343
+ ### Fixed
344
+ - **5.3.2's `useAnimationScrollGuard` didn't actually stop the autofocus page-jump for MUI's `<TextField autoFocus />`** (or any other component that focuses via `useLayoutEffect`, which is how MUI's `InputBase` implements `autoFocus`). The guard captured its scroll baseline inside its own `useEffect` — but React always flushes every `useLayoutEffect` in a commit, tree-wide, before any `useEffect` runs, with no exception for nesting. So the focus-triggered scroll (from a layout effect) had already happened by the time the guard's passive effect read `window.scrollX`/`scrollY`, meaning it captured the post-jump position as its "correct" baseline and spent the rest of the animation window faithfully restoring the wrong value — a complete no-op disguised as a fix. The baseline is now captured in a `useState` initializer, which runs during render, strictly before any effect (layout or passive) anywhere in the subtree can fire — the only capture point actually guaranteed to predate the jump. No API change.
345
+
346
+ ## [5.3.2] — 2026-08-25
347
+
348
+ ### Fixed
349
+ - **Autofocusing a child of a side panel or modal (e.g. a MUI `<TextField autoFocus />` opened via `openRightPanel`/`openLeftPanel`/`openModal`) caused the whole document to visibly scroll/jump during the panel's enter animation**, even though the panel itself animated correctly. `SidePanelRendererItem`/`ModalRenderer` mount the consumer's `<Component>` in the same commit as the slide-in/scale-in animation, so an autofocus target is a real, focusable, laid-out DOM node while still visually off-screen (the animation is a pure `transform`, not a visibility change) — and since `.rdd-side-panel` has no positioned/scrollable ancestor, the browser's native focus-scroll-into-view walked all the way up to the document, which is what visibly jumped. Added `useAnimationScrollGuard`, an internal hook that captures the scroll position on mount and snaps back to it for the duration of the enter animation (250ms for side panels, 180ms for modals) — this catches the scroll regardless of what triggers the focus, so it fixes the library's own two internal `.focus()` calls (`ConfirmationForm`, `PanelOverlay`'s search input, both of which also now pass `{ preventScroll: true }` directly) as well as any consumer's `autoFocus` content. No API change.
350
+
351
+ ## [5.3.1] — 2026-08-13
352
+
353
+ ### Fixed
354
+ - **A `SidebarTab` placed alone in `headerAction`/`footerAction` (e.g. a lone "Settings" entry — the exact pattern 5.3.0's own doc comment recommends) rendered narrower than 44px when active, with its accent bar visibly detached from the rail's edge.** `.rdd-sidebar-tab-btn.rdd-active`'s `width: var(--tab-btn-active-width, 100%)` resolves against its parent's own width; in the main `.rdd-sidebar-tabs-list` this is always stable because at least one inactive 44px sibling anchors the shrink-to-fit container, but `.rdd-sidebar-header-area`/`.rdd-sidebar-footer-area` (both introduced in 5.3.0) have no explicit width — when one holds only the active tab, its `100%` has nothing concrete to resolve against and collapses to the button's own icon-sized content (~30px). Added `min-width: 44px` to both areas, matching the base tab button's own intrinsic size — a no-op for every already-correct multi-entry case, purely layout-only so identical in both light and dark mode.
355
+
356
+ ## [5.3.0] — 2026-08-13
357
+
358
+ ### Added
359
+ - **`Sidebar`'s `showCloseButton` prop** — an opt-in "X" close button in the expanded drawer's header, alongside the tab label, as an additional way to collapse the sidebar. Wired to the exact same close path every other close control already uses (`setActiveTabId(null)`) — functionally identical to clicking the active tab's own icon again. Default `false`; omitting it leaves the drawer header byte-for-byte unchanged.
360
+ - **`Sidebar`'s `headerAction` now accepts multiple entries, and a new mirror `footerAction` prop pins entries to the bottom of the tab strip.** Both widen from a single `SidebarHeaderAction` object to `SidebarRailEntry | SidebarRailEntry[]` — an existing single-object `headerAction={{ icon, label, onClick }}` still type-checks and renders identically, since arrays are purely additive. The new `SidebarRailEntry` union also allows mixing in real `SidebarTab` entries alongside action buttons/custom renders in the same header or footer slot — a tab placed there (e.g. a "Settings" entry ending a footer's list of action buttons) behaves exactly like a main-list tab: it mounts, activates, opens the drawer, participates in `eagerMount`/`preserveState`, and is subject to the same auto-close-when-removed guard introduced in 5.1.3 — only its position in the rail differs. New exports: `SidebarRailEntry`. `SidebarHeaderActionButton`/`SidebarHeaderActionCustom` gain an optional `id` field (used for React keys when placed inside an array; unused and harmless for the existing single-object form). `footerAction` renders inside a new `.rdd-sidebar-footer-area`, pinned to the bottom via `.rdd-sidebar-tabs-list` gaining `flex: 1` — new CSS variables `--rdd-sidebar-footer-area-padding-top`/`--rdd-sidebar-footer-area-padding-bottom` (both default `8px`) mirror the existing header-area vars. `.rdd-sidebar-header-area` becomes a flex column (was center-only) so multiple header entries stack — visually identical to before for today's single-entry case.
361
+
362
+ ## [5.2.2] — 2026-08-13
363
+
364
+ ### Fixed
365
+ - **The active `Sidebar` rail tab shrank (and its accent border detached or, for the toolbar's active radio/group buttons, disappeared entirely) in light mode, for any skin that doesn't explicitly redefine these tokens itself — including `vscode`, the package's own default skin.** `--tab-btn-active-width` and seven sibling "active-tab"/"active-toolbar-button" design tokens (`--tab-btn-active-radius`, `--tab-btn-active-shadow`, `--tab-btn-active-glow`, `--tab-accent-bar-width`, `--toolbar-btn-active-shadow`, `--toolbar-btn-active-glow`, `--toolbar-accent-bar-width`) were only ever defined inside the base `[data-color-scheme="dark"]` block, with no `[data-color-scheme="light"]` counterpart, and used with `!important` and no fallback. `slate`/`nord`/`macos` (for the width) and `obsidian`/`tokyo` (for the rest) happen to redefine these themselves regardless of scheme, so they were unaffected — `vscode` redefines none of them, so in light mode every one of these `var()` references resolved to nothing: the width one fell back to shrink-to-fit (the originally reported symptom), and the two `-accent-bar-width` ones — used inside a `border-*` shorthand — invalidated the whole shorthand, resetting `border-style` to `none` and making the accent border fully disappear, not just misplace. Added a fallback directly to each `var()` call, using its existing dark-scheme value (`100%`/`0px`/`none`/`3px` as appropriate) — removes the "must remember to define this in every new scheme/skin" trap for all eight tokens at once, with zero behavior change for skins that already define them.
366
+
367
+ ## [5.2.1] — 2026-08-12
368
+
369
+ ### Fixed
370
+ - **`PanelToolbar`'s `insetTop`/`insetBottom` could become permanently stale (often `0`) after a restored layout, causing docked `PanelFloatingWindow`/managed floats to render on top of the toolbar itself.** `PanelToolbar` measured its own `offsetHeight`/`offsetWidth` exactly once, in a `useLayoutEffect` with no `ResizeObserver` and no re-measurement path — harmless on a normal live mount (already at final size when the effect fires), but during `loadLayout()`/`initialState` restoration the panel's DOM isn't necessarily settled at that exact instant, so a wrong size got baked in for the toolbar instance's entire lifetime. Every docked float then positioned itself at `top: insetTop (≈0)`/`bottom: insetBottom (≈0)` — the same origin as the toolbar — and, using a much higher `z-index`, rendered completely over its buttons. Added a `ResizeObserver` on the toolbar's own element alongside the existing initial measurement, so `insetTop`/`insetBottom` now stay correct for the lifetime of the component — this also fixes the toolbar's height changing for any other reason post-mount (button wrapping, a `buttonSize`/`variant` change, content changes), which was never reflected before either.
371
+
372
+ ## [5.2.0] — 2026-08-10
373
+
374
+ ### Added
375
+ - **`Sidebar`'s `headerAction` prop** — a single, non-toggling action button (e.g. a hamburger menu, like Google Maps') rendered above the tab strip. Unlike `SidebarTab`, it never touches `activeTabId` or the drawer — the library only renders it and forwards the click; what happens next (opening a side panel via the existing `openLeftPanel`/`openRightPanel`, a modal, a custom overlay, or nothing) is entirely up to the consumer. Two forms: `{ icon, label, onClick, disabled? }` renders a default-styled button visually consistent with the regular tab buttons (same `.rdd-sidebar-tab-btn` class, `aria-label` instead of `aria-pressed` since it's not a toggle), or `{ render: () => ReactNode }` for full control — the returned node is inserted as a direct child of the strip with no wrapping element, so a consumer's own Material UI `IconButton`, Bootstrap `Button`, or Tailwind-styled button keeps its own hover/active/focus/ripple behavior and click handling completely untouched. New exports: `SidebarHeaderAction`, `SidebarHeaderActionButton`, `SidebarHeaderActionCustom`. Fully optional and additive — omitting it leaves `Sidebar` byte-for-byte unchanged. When present, `headerAction` renders inside its own `.rdd-sidebar-header-area`, independent of the tabs' own inter-item gap (now owned by a dedicated `.rdd-sidebar-tabs-list` wrapper) — its spacing (and by extension its effective height) is fully consumer-controllable via two new CSS variables, `--rdd-sidebar-header-area-padding-top`/`--rdd-sidebar-header-area-padding-bottom` (both default `8px`, reproducing the look of a plain tab strip), following the same `--rdd-*` override convention used throughout the rest of the library instead of adding new numeric props. The strip's own `padding-top` (`38px`, aligning the first *tab* with the drawer's header bar) drops to `0` whenever `headerAction` is present, via a `rdd-sidebar-tabs-strip--has-header-action` modifier class, since the header area now owns that spacing itself; unaffected when `headerAction` is omitted.
376
+
377
+ ### Fixed
378
+ - **`openLeftPanel`/`openRightPanel`'s side panel ignored light mode**, the same defect class as the `openModal` fix above — `.rdd-side-panel`/`.rdd-side-panel-right`/`.rdd-side-panel-header`/`.rdd-side-panel-close-button:hover` used hardcoded dark literals with no `[data-color-scheme="light"]` override, never audited when the modal was fixed since that report was scoped specifically to `openModal`. Introduced `--rdd-side-panel-bg`/`-border`/`-header-bg`/`-header-border`/`-close-hover-color`, mirroring the `--rdd-modal-*` pattern exactly — dark defaults match today's literals (no dark-mode change), light-mode counterparts added alongside the existing `--rdd-modal-*`/`--rdd-window-*` overrides.
379
+
380
+ ## [5.1.4] — 2026-08-09
381
+
382
+ ### Fixed
383
+ - **`openModal`'s dialog frame ignored light mode — hardcoded dark colors made modal content unreadable against a light-themed app.** Unlike every other piece of chrome (floating windows, docked panels, sidebar, toolbars, toasts), `.rdd-modal-curtain`, `.rdd-modal-window`'s background/border, `.rdd-modal-header`'s background, and `.rdd-modal-close-button:hover`'s color were hardcoded literals with no `[data-color-scheme="light"]` override — only `.rdd-modal-window`'s text color was already a `var(--rdd-*)` reference, which is why dark mode looked correct only by coincidence (the two independently-theming systems — this library's chrome and a consumer's own UI library, e.g. MUI — happened to agree there; light mode exposed the gap once a consumer's independently light-themed text landed on a background that never stopped being dark). Introduced `--rdd-modal-curtain-bg`/`--rdd-modal-bg`/`--rdd-modal-border`/`--rdd-modal-header-bg`/`--rdd-modal-header-border`/`--rdd-modal-close-hover-color`, mirroring the exact pattern `--rdd-window-*` already uses for floating windows — dark defaults match today's literals exactly (no dark-mode visual change), with new light-mode counterparts alongside the existing `--rdd-window-*` overrides. The backdrop curtain also gets a real light-mode value (a conventional theme-neutral `rgba(0, 0, 0, 0.5)` dimming scrim) rather than staying dark-only, for full consistency with the rest of the library's chrome.
384
+
385
+ ## [5.1.3] — 2026-08-07
386
+
387
+ ### Fixed
388
+ - **`<Sidebar>` could get stuck open and empty, with no way to collapse it.** The drawer's open state was derived only from `activeTabId != null` (`isDrawerOpen`), never checking that the active id still referred to a real entry in `tabs`. If the active tab stopped existing — most commonly because a panel contributing sidebar tabs (`usePanelContribution`) changed, closed, or stopped contributing — the drawer stayed visually open at full width with an empty strip and empty body, and the *only* built-in close control (clicking the active tab's own button again) had vanished along with that tab, leaving no way to close it. `Sidebar` now watches `tabs`/`activeTabId` and calls the same `setActiveTabId(null)` used by every other close path the moment the active id no longer matches any entry in `tabs` — closing the drawer rather than silently falling back to a different tab the user didn't choose, whether `tabs` went fully empty or just lost that one specific entry. In controlled mode (`activeTabId` prop), this surfaces as the existing `onActiveTabChange(null)` callback, same as any other close — actually closing still depends on the consumer reflecting that back into their own state, as with every other imperative close path today.
389
+
390
+ ## [5.1.2] — 2026-08-07
391
+
392
+ ### Fixed
393
+ - **A leaf's drop-target "cross" (the 5-box overlay for docking within the grid, shown while dragging a floating window or a docked tab) never won hover priority over the workspace's outer-edge or corner drop zones — in every browser, most consistently broken in Safari.** Root cause: `.rdd-dock-drop-zone-overlay` (the cross's wrapper) had a hardcoded `z-index: 100`, far below `.rdd-workspace-edge-trigger` (`--rdd-z-base + 8999`) and `.rdd-corner-zone` (`--rdd-z-base + 9000`). Since none of the intervening ancestors establish their own stacking context, the edge/corner overlays sat visually on top of the cross wherever a leaf's cross fell within the outer edge band (any leaf touching the workspace boundary — the common case) or a corner region, silently intercepting the pointer events meant for the cross box underneath: the box never highlighted there, and the edge/corner highlighted instead. Rebased `.rdd-dock-drop-zone-overlay` onto the same `--rdd-z-base` scale, above both (`+9001`), so the more specific per-leaf target now always wins. Also hardened `handleHoverDropZone` to explicitly clear `activeEdgeDrop`/`activeCornerAnchor` when a cross box is hovered, mirroring the pattern the corner-zone's own hover handler already used for the edge — a defensive guard against stale hover state surviving a rapid overlapping-overlay re-render without an intervening pointer move, which WebKit is more prone to than Chromium/Firefox. Purely cosmetic during a drag — actual drop placement was already correct in all browsers, since only one zone was ever genuinely hovered at release time in practice.
394
+ - **Each drop-target box's own highlight (background/border/scale/glow) never worked in Safari, and couldn't work on touch at all.** Unlike everything else in this overlay, `.rdd-dock-target-box`'s highlight was driven by the native `:hover` pseudo-class rather than the `activeDropZone` state that already reliably tracks the current target for mouse, pen, *and* touch (the corner-anchor zones already got this right, via a state-driven `rdd-corner-zone--hovered` modifier class). `:hover` never reliably recalculates during an active drag in Safari, and doesn't exist on touch at all, since there's no persistent hover concept. Replaced `.rdd-dock-target-box:hover` with a state-driven `rdd-dock-target-box--active` class, applied when `activeDropZone` matches that specific box — one mechanism now drives the box highlight, the preview rectangle, and touch's own hit-testing alike.
395
+
396
+ ## [5.1.1] — 2026-08-07
397
+
398
+ ### Fixed
399
+ - **Dragging a floating window — either by a resize handle or by its title bar — selected text in whatever docked panel sat behind it, Safari/WebKit only.** The shared `startPointerDrag()` mechanics (`src/components/dragResize.ts`) support an `activeClasses` option that toggles a `document.body` class — and matching `user-select: none` CSS — for the duration of a drag; the workspace grid splitter and the sidebar drawer resizer already passed it, which is why those two were never affected.
400
+ - **Resize handles**: both floating-window resize-handle implementations (`WindowManager`'s `startResize` and `PanelOverlay`'s `handleResizePointerDown`) never passed `activeClasses` at all, so nothing suppressed selection while their handles were dragged. Both now pass it, toggling `rdd-resizing-active`, whose CSS rule also gained `-webkit-user-select: none` alongside the existing unprefixed property, for full Safari reliability.
401
+ - **Header drag (moving an already-floating window)**: unlike resize, this was never built on `startPointerDrag()` at all — both `WindowManager`'s `startDrag` and `PanelOverlay`'s `handleHeaderPointerDown`/`handleWindowPointerMove` are independent, hand-rolled pointer-drag implementations with extra logic (drop-zone/tab-swap/corner-anchor hover detection, touch long-press-to-drag) that the shared utility doesn't model, so neither ever toggled a body-level selection-suppressing class. Both now toggle a new `rdd-dragging-active` class on `document.body` for the drag's duration (paired with `-webkit-user-select`/`user-select: none` in CSS), added at pointerdown rather than after any move threshold, since WebKit can start extending a selection from the very first pixel of movement. `WindowManager`'s `startDrag` also gained the `e.preventDefault()` it was missing entirely, and both implementations now clean up correctly on `pointercancel`, not just `pointerup`, so an interrupted drag can't leave selection disabled indefinitely.
402
+ - **Dragging a docked panel's tab out** (the drag-preview "ghost" label shown before it becomes an actual floating window, or before it's dropped onto a new dock target): a third, independent hand-rolled implementation, `WindowManager`'s `handleTabDragStart`, had the identical gap — no `preventDefault()`, no selection-suppressing class. It now reuses the same `rdd-dragging-active` class (no CSS changes needed, since this is the same kind of "moving a panel around" interaction as the header-drag case above), added/removed at the same points, with the same `pointercancel` hardening.
403
+
404
+ In all cases, Chromium/Firefox apparently tolerate the drag without this CSS-level suppression (via `preventDefault()` alone), but Safari doesn't once a native selection drag is already extending.
405
+
406
+ ## [5.1.0] — 2026-08-04
407
+
408
+ ### Added
409
+ - **`openPanel(id, component, options)` now accepts `props`** — custom per-instance data spread onto the panel component alongside `panelId` (`<Component {...props} panelId={id} />`), matching `openModal`/`openLeftPanel`/`openRightPanel`'s already-unconstrained `props` argument. Previously a docked/floating panel received exactly one prop — `panelId` — with no way to pass anything else, forcing every app with per-instance data (a document's filename+content, a record id, a filter) into hand-rolling an external store keyed by `panelId`. There is **no type restriction** on `props` — see the next entry for why.
410
+ - **`PanelInfo.serializable: boolean`, computed automatically** — whether a panel's current `props` can round-trip through `saveLayout()`/`loadLayout()`, checked recursively for functions, symbols, React elements, class instances, `Map`/`Set`, or `undefined` anywhere in the tree (`Date` is treated as serializable-enough, matching `JSON.stringify`'s own behavior). A panel opened with non-serializable `props` isn't rejected or blocked — it keeps rendering and working normally on screen, it's simply **excluded from the next `saveLayout()` call**, pruned from `gridRoot`/`floating`/`minimized` in that saved snapshot (non-mutating — the live workspace is never touched by computing a save) so a later `loadLayout()` never references a panel it has no data to recreate. The new `isSerializable()` utility backing this is exported for apps that want to apply the same check themselves.
411
+ - **`'layout:panels-excluded'` event**, published from inside `saveLayout()` itself whenever that specific call excluded at least one panel — payload `{ panels: { id, component }[] }`. A passive flag alone isn't enough for the case that actually matters (e.g. a floating window rendering data from a live class instance: fine on screen right now, but nobody may be polling `serializable` at the exact moment a save happens and it silently drops out) — this is deliberately just a signal, not a UI opinion; decide for yourself whether it becomes a toast, a console warning, or nothing. New `WorkspaceClient.onPanelsExcluded()` convenience method, matching the existing `onPanelOpen`/`onPanelClose`/etc. pattern.
412
+ - **`FormContainerContract.registerStateProvider(getState)`** (docked/floating panels only) — registers a callback reporting a panel's *current* restorable state, pulled fresh by `saveLayout()` every time it's called, for state a panel accumulates after opening that static `props` alone can't capture (scroll position, an in-progress edit, a view-mode toggle). Return `undefined` to fall back to the panel's static `props` for that save. The returned value goes through the same serializability check as static props, re-evaluated on **every** save — a provider-backed panel's exclusion status can flip from one save to the next, unlike a static-props-only panel, which is classified once at open time. New `WorkspaceClient.registerStateProvider()`/`unregisterStateProvider()` mirror the existing `registerCloseGuard()`/`unregisterCloseGuard()` pattern exactly. Not added to left/right side panels or modals — they already have a complete, different answer to this via their own `props` argument plus `updateInstance`.
413
+ - **`openPanel`'s `dedupeKey` option, and `findPanelId(component, dedupeKey)`** — if another open panel of the same `component` already has the given `dedupeKey`, `openPanel` focuses that existing panel instead of creating a new one (the new call's `id`/`props` are ignored), the same way re-opening an already-open exact `id` already focuses it instead of duplicating it. For callers who can't guarantee they'll reuse the same literal `id` for the same logical entity across call sites — `isOpen(id)`/`focusPanel(id)` already solve this when the id *is* known and consistent; `dedupeKey` covers the case where it isn't.
414
+ - **`'layout:changed'` event** — coalesces open/close/minimize/restore/dedupe-redirect into one signal for autosave-style consumers, instead of subscribing to four (now potentially more) separate lifecycle events plus a fallback interval. Deliberately scoped, not oversold: it cannot observe a `registerStateProvider` callback's return value changing on its own (that's a pull, unobservable without the panel notifying separately), nor resize/split-ratio-drag/dock-rearrange, which have no hooks yet. New `WorkspaceClient.onLayoutChanged()` convenience method.
415
+ - **`SerializedLayout.version` is now written as `2`** (previously `1`, and never actually read/branched on since the field's introduction) — panels may now carry `props`/`dedupeKey`, and a saved payload may omit panels the live workspace still has open (see `serializable` above). Old saved layouts (version `1` or absent) still load correctly, unchanged — this is a forward-looking marker for the *next* migration to branch on, not a breaking change itself.
416
+
417
+ All of the above is additive and backward-compatible: every new field is optional and a panel that doesn't use `props` behaves identically to before; old saved layouts load unchanged since `props`/`dedupeKey`/`serializable` are never validated per-panel on load; new layouts saved by this version degrade gracefully when loaded by an older library version, which simply never reads the new fields.
418
+
419
+ ## [5.0.0] — 2026-08-03
420
+
421
+ ### Changed
422
+ - **BREAKING: `useSidebar()`, `useSidebarTab()`, `useToolbar()`, `usePanelContribution()`, and `useActivePanelContribution()` now throw when used outside their required provider**, instead of silently returning a no-op object (and logging a `console.warn`). This aligns them with `useWindowManagerActions()`, `useWindowManagerState()`, `usePanelState()`, `usePanelActions()`, and `useShowContextMenu()`, which already threw — previously, "does this hook throw or degrade gracefully?" had no learnable rule and depended on which hook you were looking at. `DockableDesktopProvider` already wraps every provider these hooks need, so apps using it are unaffected; only code calling one of the five listed hooks with **no** ancestor provider at all needs to add one (or catch the resulting error, if graceful degradation outside a provider is genuinely required).
423
+ - **BREAKING: every CSS class and custom property the library renders is now prefixed with `rdd-`** (e.g. `floating-window` → `rdd-floating-window`, `--accent-color` → `--rdd-accent-color`). An audit of framework-agnosticism (the library's primary users build with Material-UI, React-Bootstrap, Tailwind, and shadcn/ui) found the previous naming was an inconsistent mix of five prefixes (`dw-`, `v2-`, `sb-`, `fw-`, `wm-`) plus ~100 unprefixed classes, including a bare `.active` that collides with Bootstrap's own global `.active`, and `:root`-scoped design tokens using the same short-generic-name convention shadcn/ui uses for its own theme tokens. One consolidated, low-collision-risk prefix means anything you see in devtools is instantly recognizable as belonging to this library. Only the library's own rendered output was renamed — the demo apps' own classes (e.g. `sb-*`) are unaffected, as they're sample-app code, not library API. See the [Migration Guide](https://felipecarrillo100.github.io/react-dockable-desktop/guide/migration) for the full old-name → new-name tables if you have custom CSS overriding the library's internal classes or default variable values.
424
+ - **BREAKING: the library no longer sets cosmetic global CSS.** Previously, importing `styles.css` set `font-family`/background/text-color on `html, body, #root` and restyled scrollbars on the bare `*` selector — affecting the consumer's entire page, not just the workspace. These are now scoped to `.rdd-workspace` (the root element `<WindowManager />` renders) and its descendants only. The `margin`/`padding`/`width`/`height`/`overflow` reset on `html, body, #root` is unchanged — it's structural, not cosmetic: `.full-viewport-layout` and every percentage-height element the workspace nests inside (including `WindowManager`'s own root) can only resolve `height: 100%` if this chain has a real height all the way to `<html>`.
425
+ - **BREAKING: animations are now enabled by default.** Previously, every transition/animation on the *entire page* — not just the library's own — was force-disabled (`!important`) unless `<html>` had an undocumented `enable-animations` class that nothing in the library itself ever added; only the demo apps' own UI toggle knew about it. `<WindowManager animations={false} />` now opts out, scoped to only the library's own elements via the new `rdd-` prefix — it never touches a consumer's own transitions/animations elsewhere on the page, in either state.
426
+ - **BREAKING: `<Sidebar>`'s deprecated `drawerWidth` (string) prop is removed.** It was deprecated in v3.1.0 in favor of `defaultWidth` (number, pixels); replace `drawerWidth="280px"` with `defaultWidth={280}`. `defaultWidth`'s own default (when omitted) also changed from `220` to `280` — a more comfortable fit for typical drawer content (forms, labeled toggles, card metadata).
427
+
428
+ ### Added
429
+ - **`WorkspaceClient` now mirrors the full `WindowActions` interface** — added `updateSplitSizes`, `updateFloatingPosition`, `setDraggedPanelId`, `dockPanelToGroup`, `movePanelOrder`, `closeLeafGroup`, `registerCloseGuard`, `unregisterCloseGuard`, `setPanelDirty`, `updatePanelTitle`, `requestClosePanel`, `dockPanelToWorkspaceEdge`, and `showContextMenu`. Previously 13 of the ~28 actions available via `useWindowManagerActions()` had no equivalent on `WorkspaceClient`, so code built entirely against the imperative client (rather than hooks) could hit an unexpected capability gap.
430
+ - **Serialized layouts now carry a `version` field** (`SerializedLayout` type, currently `1`) — purely additive; layouts saved before this change (with no `version` field) still load correctly. This gives the *next* breaking change to the layout JSON shape a clean version to branch on, instead of another ad hoc field-presence sniff like the existing `stickyRight`/`stickyBottom` → `anchor` migration.
431
+ - **`startPointerDrag()` and `computeResizedRect()` are now public** (`src/components/dragResize.ts`) — the same pointer-capture mechanics and 8-directional resize math the built-in grid/sidebar/floating-window resizers already share internally, exported so panel content can build custom resizable dividers or handles without reimplementing pointer capture and cleanup. The demo's Markdown Editor preview divider, previously hand-rolled for exactly this reason, now uses it.
432
+ - **`useColorScheme()` hook** — reactively reads the workspace's `data-color-scheme` attribute (`'dark' | 'light'`), for panel content that needs to react in JS, not just CSS, to the same scheme the workspace is using (e.g. swapping a map's tile layer or an embedded editor's theme). This logic previously existed independently in `WindowManager` itself and in 4 separate demo call sites — all 5 now share one implementation.
433
+ - **`usePanelSize()` hook** — reactive alternative to calling `getDimensions()` yourself: returns the panel's current `{ width, height }` (or `null` before layout) and re-renders on change. It wraps the existing `onResize`/`getDimensions()` mechanism on `FormContainerContract`, which already correctly tracks a panel's box across docking, floating, and tab changes — several demo map panels had independently built a second, redundant `ResizeObserver` on their own container to get the same signal; they now use this instead.
434
+ - **`zIndexBase` config on `WorkspaceClientConfig`/`WindowManagerProviderProps`** (default `1000`, matching today's behavior exactly) — floating windows and the library's own chrome overlays (context menu, toolbar flyout, modal stack, toast, workspace edge zones) previously used three independent, un-synced z-index systems with hardcoded values (8000–10100+) that always sat above a host app's own Material-UI (1300–1500) or Bootstrap (1055–1080) overlays, while the floating-window base (1000) sat *inside* MUI's modal range — a real collision risk if a consumer's own modal is triggered from inside a panel. All of these now derive from one `--rdd-z-base` CSS variable via fixed offsets that preserve today's exact relative order; `zIndexBase` shifts everything together, letting you place the library's entire stacking context above or below a host app's own overlays.
435
+ - **`data-color-scheme` is now mirrored onto `document.documentElement`**, matching the existing `data-workspace-skin` mirroring. `<Sidebar>`/`<Toolbar>` are DOM siblings (or, for `<Sidebar>`, an ancestor) of `<WindowManager>`, not descendants — previously, `[data-color-scheme="light"]`-scoped tokens (including all `--sidebar-*` variables) only reached them if the consumer independently set the attribute themselves, despite a code comment claiming this already worked "same as skin."
436
+
437
+ ### Fixed
438
+ - **`WorkspaceClient.initialState` silently skipped the `stickyRight`/`stickyBottom` → `anchor` migration that `loadLayout()` already applied** — the two entry points independently duplicated their shape-checking logic, and only one of the two copies had the migration. Both now share a single `parseLayoutPayload()` function, so a legacy-format layout behaves identically regardless of which entry point loads it.
439
+ - **Four independent implementations of "pointer-capture drag, resize on move" had quietly drifted apart** — the workspace grid split resizer, the sidebar drawer resizer, and two separate floating-window 8-direction resize-handle implementations (one in `WindowManager`, one in `PanelOverlay`) each hand-rolled the same mechanics. This is the same class of drift that caused the docked-panel resize bug fixed in 4.3.0 (a property present in one implementation's inline styles but missing in the other). All four now share `startPointerDrag()` and `computeResizedRect()` (`src/components/dragResize.ts`) for the pointer-capture/delta/cleanup mechanics and the 8-directional resize math respectively — behavior is unchanged for every existing call site (verified: unbounded floating-window growth stays unbounded, container-clamped `PanelOverlay` resizing stays clamped, grid/drawer resize math is bit-for-bit the same).
440
+
441
+ ## [4.3.0] — 2026-08-02
442
+
443
+ ### Added
444
+ - **`usePanelContribution(contribution)`** — lets any panel publish `toolbarItems` and/or `sidebarSections` that are only surfaced while that panel is `state.activePanelId`. Call on every render; republishes automatically when the contribution changes, and is cleared on unmount. Independent panel instances (e.g. two maps) keep fully independent contributed state — nothing is shared or keyed globally. No-op with a `console.warn` outside a `PanelContributionProvider`.
445
+ - **`useActivePanelContribution()`** — returns whatever the currently active panel has published, or `null` if none. Same no-op-with-warning behavior outside a `PanelContributionProvider`, matching the existing `useToolbar()`/`useSidebar()` convention.
446
+ - **`useMergedToolbarItems(staticItems)`** / **`useMergedSidebarTabs(staticTabs, fallbackIcon?)`** — convenience wrappers around `useActivePanelContribution()` for the common case: append the active panel's contributed toolbar items (behind a separator) / sidebar sections (as dynamic tabs, via `sidebarSectionToTab`) to a static list, unchanged when there's nothing to add. `useActivePanelContribution()` stays exported for manual control.
447
+ - **`sidebarSectionToTab(section, fallbackIcon?)`** — converts a `PanelSidebarSection` into a `SidebarTab` for `<Sidebar tabs={...}>` (`renderContent: () => section.content`, with a fallback for `SidebarTab`'s required `icon`).
448
+ - **`PanelContributionProvider`** — the context provider backing the hooks above. Mounted automatically by `DockableDesktopProvider`; only needed manually when composing `WindowManagerProvider` directly.
449
+ - **`PanelContribution` / `PanelSidebarSection` types** — `PanelContribution` is `{ toolbarItems?: ToolbarItem[]; sidebarSections?: PanelSidebarSection[] }`; `PanelSidebarSection` is `{ id, label, icon?, content }`.
450
+ - **`active?: boolean` on `ToolbarToggleItem`** — controlled-mode escape hatch mirroring `ToolbarGroupItem`'s existing `activeItemId`/`onActiveItemChange` pattern. When provided, the toggle reads `active` instead of `ToolbarContext`'s shared modifier state, and skips writing to it on click — this is what lets contributed toggle buttons (e.g. a per-map controller selector: Pan/Draw/Measure) report independent active state per panel instance instead of colliding on a shared id. Omitting `active` preserves prior uncontrolled behavior exactly.
451
+ - **`options.focus?: boolean` on `openPanel()`** — escape hatch to open a panel without changing `activePanelId` (`default: true`). Lets an app open several panels and choose exactly which one ends up focused (e.g. "focus the first one opened") without fighting the default.
452
+ - **Panel Contributions guide** (`docs-site/guide/panel-contributions.md`) and README hooks-table rows.
453
+
454
+ ### Fixed
455
+ - **`openPanel()` didn't consistently focus the panel it opened** — despite its own doc comment claiming otherwise, `state.activePanelId` was only set when re-opening an already-*floating* panel; brand-new panels, restored-from-minimized panels, and re-opened *docked* panels never set it. `openPanel()` now sets `activePanelId` in every branch by default, matching its documented behavior — confirmed safe: no call site in this repo relied on the previous gap, and two already worked around it manually.
456
+ - **Docked panels could resize based on unrelated internal content** — switching an unrelated panel's internal tab (e.g. Control Center, Markdown Editor) could shift the width of neighboring panels or the `Sidebar` drawer by a few pixels. The actual source: `Sidebar`'s wrapper around `{children}` used `flex: '1 1 auto'`, whose `auto` basis is computed from its content's max-content size — `minWidth: 0` alone only bounds how far something can *shrink*, not that content-driven starting size. Changed to `flex: '1 1 0%'`, so the wrapper's size comes purely from `flex-grow`'s share of space regardless of content. Also hardened `WorkspaceGrid`'s recursive per-child wrapper (`WindowManager.tsx`) with `minWidth`/`minHeight: 0`, closing the equivalent gap between sibling leaves within the same grid.
457
+
458
+ ## [4.2.2] — 2026-08-02
459
+
460
+ ### Fixed
461
+ - **RTL corner-anchor positioning inconsistency** — the resize-triggered realignment effect in `WindowManager` recomputed anchored floating windows' position using the raw, un-flipped anchor string, disagreeing with the (already RTL-aware) render-time stacking logic. Anchored windows now derive their visual position entirely from `anchor` + the element's `dir` attribute via CSS logical properties (`insetInlineStart`/`insetInlineEnd`) — both code paths now agree by construction, and switching direction at runtime (e.g. via `setDirection()`) re-mirrors already-anchored windows with no other action needed.
462
+
463
+ ### Changed
464
+ - Internal: de-duplicated `flipZoneHorizontal` (previously defined separately in `WindowManager.tsx` and `PanelOverlay.tsx`) into a single shared `src/components/anchorGeometry.ts` module.
465
+ - Internal: `PanelFloatingWindow` (Panel Overlay) now sets an explicit `dir` attribute and positions its corner anchor via CSS logical properties, replacing a manual `isRtl`-based left/right flip — consistent with how `PanelToolbar` already positions itself in the same file.
466
+
467
+ ## [4.2.1] — 2026-06-29
468
+
469
+ ### Fixed
470
+ - **`showContextMenu` missing from published bundle** — `showContextMenu` on `useWindowManagerActions()` was implemented in source but the 4.2.0 package was published without rebuilding `dist/`. Added `prepublishOnly` script to ensure the bundle is always rebuilt before publishing.
471
+
472
+ ### Added
473
+ - **`onActivate` / `onDeactivate` on `FormContainerContract`** — push-based callbacks that fire when a panel becomes or stops being the globally active panel (`state.activePanelId`). Eliminates the need to subscribe to `useWindowManagerState` and compare `activePanelId` from inside each panel. `onDeactivate` also fires when the panel is destroyed while active (before `onClose`). Returns an unsubscribe function.
474
+ - **`onContainerTypeChange` on `FormContainerContract`** — fires with the new `ContainerType` whenever the panel transitions between `'dockable-panel'` (docked in the grid) and `'floating-window'` (detached floating window). Does not fire during minimize/restore cycles — use `onMinimize` / `onRestore` for those. Returns an unsubscribe function.
475
+ - **`getDimensions()` on `FormContainerContract`** — synchronous getter that returns the current `{ width: number; height: number }` of the panel, or `null` before the first layout. Reads from the same module-level map populated by the existing `ResizeObserver`-backed `onResize` callback.
476
+ - **`requestMinimize()` on `FormContainerContract`** — imperative method that minimizes the panel to the taskbar. No-op if the container type does not support minimize. Symmetric counterpart to the existing `requestClose()`.
477
+ - **`'floating-window'` value in `ContainerType`** — `containerType` on the contract now correctly reports `'dockable-panel'` for panels docked in the workspace grid and `'floating-window'` for panels in a detached `PanelFloatingWindow`. Previously the field was stuck at `'standalone'` for all dockable panels.
478
+
479
+ - **Workspace corner anchor zones** — four 80×80 px proximity snap zones appear at each workspace corner during any panel drag (docked tab or floating window). Dropping into a zone anchors the window to that corner; uses the same visual style (dashed accent-color border, `var(--accent-color)`) as the inner panel drop zones.
480
+ - **Anchor stacking** — multiple windows anchored to the same corner stack with 8 px gaps, uncapped. Dragging a window away from its corner returns it to free-float.
481
+ - **`anchor` option on `openPanel`** — new floating windows can be spawned pre-anchored: `openPanel('id', 'comp', { initialTarget: 'floating', anchor: 'top-right' })`.
482
+ - **`anchor` param on `floatPanel`** — `floatPanel(id, rect?, anchor?)` floats and anchors in one atomic call.
483
+ - **`defaultAnchor` on `PanelRegistryEntry.defaultOptions`** — sets the default corner for all instances of a registered component; replaces `defaultStickyRight`/`defaultStickyBottom`.
484
+ - **RTL corner anchoring** — all corner snap zones and anchor render positions mirror correctly when `dir="rtl"`.
485
+ - **RTL inner floating-window drop detection** — `PanelOverlay` inner floating window drop zones now correctly detect the logical corner in RTL mode; dragging no longer drops on the opposite corner.
486
+ - **`FloatAnchor` type** — exported from the package root: `import type { FloatAnchor } from 'react-dockable-desktop'`.
487
+ - **`toast` singleton** — imperative notification API with `toast()`, `toast.info()`, `toast.success()`, `toast.warning()`, `toast.error()`, `toast.dismiss()`, and `toast.promise()`. Works from anywhere — inside or outside React.
488
+ - **`<ToastContainer>`** — portal-rendered notification host. Props: `position` (`top-right` default), `width` (320px default), `maxVisible` (3), `defaultDuration` (5000ms), `defaultClosable`, `pauseOnHover`, `animation` (`slide`/`fade`/`none`), `newestOnTop`, `progressBar`, `adapter`.
489
+ - **`ToastAdapter` interface** — delegate all `toast.*` calls to an external notification library (Ant Design, MUI Snackbar, Sonner, etc.) without changing call sites.
490
+ - **Toast theming tokens** — `--toast-bg`, `--toast-border`, `--toast-info-color`, `--toast-success-color`, `--toast-warning-color`, `--toast-error-color`, `--dw-toast-offset-top`, `--dw-toast-offset-bottom`. All switch automatically with `[data-color-scheme="light"]`.
491
+ - **Toast Notifications guide** — new documentation page covering the full Toast API, positioning, theming, queue behaviour, `toast.promise()`, dedup by id, and the custom adapter pattern.
492
+ - **`PanelOverlayRoot`** — context provider and container div for the Panel Overlay system. Coordinates toolbar insets, z-ordering, drag state, drop-zone detection, and managed-window registry for all descendant overlay components.
493
+ - **`PanelToolbar`** — panel-scoped toolbar that attaches to any edge of a `PanelOverlayRoot`. Props: `position` (top/bottom/left/right), `variant` (transparent/frosted/solid), `buttonVariant` (ghost/soft/outlined/filled), `buttonSize`. Left/right toolbars auto-inset by the heights of any registered top/bottom toolbars.
494
+ - **Toolbar primitives** — `ToolbarButton`, `ToolbarToggle`, `ToolbarSeparator` (exported as `PanelToolbarSeparator`), `ToolbarSpacer`, `ToolbarCenter`, `ToolbarItem` (exported as `PanelToolbarItem`), `ToolbarSearchInput` for composing panel toolbar contents.
495
+ - **`PanelFloatingWindow`** — declarative single floating window inside a panel overlay. Props: `id`, `title`, `open`, `onClose`, `defaultAnchor`, `defaultWidth`, `defaultHeight`. Supports 8-direction resize, drag-to-free, drag-to-dock at four corners with smooth stacking transitions.
496
+ - **`usePanelFloatingWindow()`** — convenience hook returning `{ isOpen, open, close }` for a single boolean-toggled `PanelFloatingWindow`.
497
+ - **`usePanelFloatingWindowManager()`** — imperative hook returning `{ open(id, config), close(id), closeAll(), isOpen(id), openIds }`. Enables dynamically spawning N named floating windows from data or event handlers at runtime.
498
+ - **`ManagedWindowConfig`** interface — `{ title: string, content: ReactNode, anchor?: FloatAnchor, width?: number, height?: number }`.
499
+ - **`PanelFloatingWindowManagerHandle`** interface — TypeScript type for `usePanelFloatingWindowManager()` return value.
500
+ - **Panel Overlay guide** — new documentation page covering the full Panel Overlay system.
501
+
502
+ ### Changed
503
+ - Internal: split the monolithic `PanelOverlayCtx` into three focused contexts (`PanelToolbarContext`, `PanelManagerContext`, `PanelOverlayContext`) — each consumer only re-renders on changes to its own slice. `PanelToolbar` no longer re-renders during window drag events; `usePanelFloatingWindowManager` consumers no longer re-render on z-order or drag-state changes.
504
+ - Internal: replaced O(n) `isActive` calculation in `FloatingWindowBody` with an O(1) `topId` field set by `focusWindow`.
505
+
506
+ ### Removed
507
+ - **`openPanel` options `stickyRight` / `stickyBottom`** — replaced by `anchor?: FloatAnchor | null`. Saved layouts containing the old JSON fields are automatically migrated by `loadLayout`.
508
+ - **`PanelRegistryEntry.defaultOptions.defaultStickyRight` / `defaultStickyBottom`** — replaced by `defaultAnchor?: FloatAnchor`.
509
+
510
+ ## [4.2.0] — 2026-06-29
511
+
512
+ ### Added
513
+ - **`showContextMenu(options)` on `useWindowManagerActions`** — imperative method to trigger the shared workspace context menu from any panel, including panels in WebGL canvases, side drawers, and modals. Routes through the active `ContextMenuProvider` (managed automatically by `DockableDesktopProvider`). > **Note:** this was inadvertently missing from the 4.2.0 published bundle — use `4.2.1` or later.
514
+ - **`contextMenuAdapter` prop on `<DockableDesktopProvider>`** — sets the context menu adapter for the workspace-level `ContextMenuProvider`. Defaults to `DefaultContextMenuAdapter`. All siblings of `<WindowManager>` in the provider tree — `<Sidebar>`, `<SidePanelRenderer>`, `<ModalStackRenderer>` — share the same context menu instance and have access to `ContextMenuContext`.
515
+ - **`<ContextMenuProvider adapter? ...>`** — standalone provider that mounts the context menu and exposes it to all descendants via `ContextMenuContext`. Managed automatically by `DockableDesktopProvider` in typical usage; can also be placed manually above `DockableDesktopProvider` for full control. Accepts all `ContextMenuProps` (`formatMessageProvider`, `onShow`, `onHide`, etc.) to configure the mounted adapter.
516
+ - **`useShowContextMenu()`** — hook returning the `show` function from the nearest `<ContextMenuProvider>`. Works from any component inside `DockableDesktopProvider` or a standalone `<ContextMenuProvider>`.
517
+
518
+ ### Fixed
519
+ - **`ContextMenu` stays open on WebGL canvas click/tap** — The click-outside dismiss listener was registered on `mousedown` in the bubble phase. WebGL gesture controllers (LuciadRIA, MapLibre, Three.js, etc.) call `stopPropagation()` on pointer events to claim the interaction, preventing the bubble-phase handler from ever reaching `document`. Fixed with two complementary listeners: `pointerdown` in capture phase (fires before any canvas handler; covers touch and stylus) and `click` on `window` (synthetic click fires after the full press cycle and survives `stopPropagation` on `mousedown`/`pointerdown`, making it the reliable fallback for WebGL canvases).
520
+ - **`ContextMenuProvider` and `useShowContextMenu` exported as type-only** — corrected to value exports so they can be rendered and called at runtime. They were accidentally placed in an `export type {}` block which erases them at build time.
521
+
522
+ ## [4.0.0] — 2026-06-16
523
+
524
+ ### Breaking Changes
525
+ - **`replace-react-contexify` peer dependency removed.** The library no longer requires or uses it. Remove the package and delete its CSS import from your entry file. All existing user code continues to work unchanged. See the [v3→v4 migration guide](docs-site/guide/migration.md).
526
+
527
+ ### Added
528
+ - **Built-in `<ContextMenu>` component** — zero-dependency, portal-rendered context menu styled with design tokens. Supports simple items, separators, sub-menus (one level), checkbox items, icons, and i18n labels. Viewport-clamped, RTL-aware, Esc-to-close.
529
+ - **`ContextMenuAdapter` interface** — strategy pattern for swapping the context menu implementation. Pass `contextMenuAdapter` to `<WindowManager>` to use a custom or design-system menu.
530
+ - **`DefaultContextMenuAdapter`** — default adapter wrapping the built-in `<ContextMenu>`.
531
+ - **New exports:** `ContextMenu`, `DefaultContextMenuAdapter`, `ContextMenuHandle`, `ShowContextMenuOptions`, `ContextMenuAdapter`, `ContextMenuProps`, `ContextMenuCheckbox`, `ContextMenuLabel`, `MenuItemAction`.
532
+ - **Context Menus guide page** — dedicated documentation covering `usePanelContextMenu`, all item shapes, standalone `<ContextMenu>` usage, and the adapter pattern.
533
+
534
+ ### Changed
535
+ - Context menu item hover colour now follows `--toolbar-btn-hover-bg` (skin-aware) instead of hardcoded `#094771`, matching the toolbar flyout hover pattern.
536
+ - `<WindowManager>` gains optional `contextMenuAdapter` prop (fully backward-compatible; defaults to `DefaultContextMenuAdapter`).
537
+
538
+ ### Removed
539
+ - `replace-react-contexify` peer dependency.
540
+ - `import 'replace-react-contexify/styles.css'` no longer needed.
541
+ - `.react-contexify` CSS override block from `src/index.css`.
542
+ - Development warning about missing `replace-react-contexify` stylesheet.
543
+
544
+ ## [3.2.0] — 2026-06-15
545
+
546
+ ### Added
547
+ - **Per-skin active state design language** — Sidebar tabs and Toolbar buttons now render a distinct per-skin visual pattern driven entirely by CSS custom properties (`--tab-btn-active-width`, `--tab-btn-active-radius`, `--tab-btn-active-shadow`, `--tab-btn-active-glow`, `--tab-accent-bar-width`, `--toolbar-btn-active-shadow`, `--toolbar-btn-active-glow`, `--toolbar-accent-bar-width`). Seven skins, seven patterns: transparent bar (`vscode`), floating glass chip (`macos`), fluent pill (`slate`), bridge pill (`chrome`), horizontal line indicator (`nord`), inset glow (`obsidian`), neon pulse (`tokyo`). Fully overridable in custom skins. CSS-only, no API changes.
548
+
549
+ ### Changed
550
+ - **Documentation overhaul** — All guides updated to reflect the full v3.1.0 API surface: Toolbar group items, Sidebar resize props, new hooks, `taskbarVisibility`, and complete skin token reference.
551
+
552
+ ## [3.1.0] — 2026-06-13
553
+
554
+ ### Added
555
+ - **`<Toolbar>` component** — Vertical/horizontal strip hosting `action`, `radio`, `toggle`, `group`, and `separator` items. State lives in `DockableDesktopProvider`; `useToolbar()` reads/writes from any panel.
556
+ - **`ToolbarGroupItem` (`type: 'group'`)** — Collapsed tool-family button with a sub-tool flyout. Supports uncontrolled (state in ToolbarContext) and controlled (`activeItemId` / `onActiveItemChange`) modes.
557
+ - **Touch & tablet support** — All drag and resize surfaces migrated to the Pointer Events API. Long-press (300 ms) initiates tab drag on touch; instant capture on mouse/pen as before. Taskbar chips support hover preview and long-press context menu on touch devices.
558
+ - **8-direction resize handles** — Floating windows now render N, NE, E, SE, S, SW, W, NW resize handles.
559
+ - **`taskbarVisibility` prop** — `<WindowManager taskbarVisibility="always" />` with three modes: `'always'` (permanent bar, new default), `'compact'` (show only with minimised panels), `'autohide'` (overlay with 8 px peek strip).
560
+ - **Resizable Sidebar drawer** — Users can drag the drawer edge to resize. New props: `defaultWidth` (px), `minWidth`, `maxWidth`, `onWidthChange`.
561
+ - **Sidebar `visible` / `stripVisible` props** — `visible` collapses the entire sidebar; `stripVisible` collapses only the activity bar strip. Both accept paired `onVisibilityChange` / `onStripVisibilityChange` callbacks.
562
+ - **`SidebarHandle` additions** — `showStrip()`, `hideStrip()`, `setWidth(px)`, `getWidth()` added to the imperative ref.
563
+ - **`useSidebar()` hook** — Programmatic Sidebar control (openTab, closeDrawer, getActiveTab) from any component in the tree — no ref or prop drilling required.
564
+ - **`useSidebarTab()` hook** — Self-control for content inside a Sidebar tab: `tabId`, `onOpen`, `onClose`, `openTab`.
565
+ - **`usePanelContextMenu()` hook** — Inject dynamic right-click context menu items into a panel from inside the panel component. Items are re-read on every menu open; state-driven enable/disable updates automatically.
566
+ - **Smart resizer hit areas** — The horizontal split resizer's grab zone now extends only upward, eliminating accidental activation when clicking tabs below.
567
+
568
+ ### Changed
569
+ - **Skin scope** — `data-workspace-skin` is now applied to `document.documentElement` so Toolbar and Sidebar always inherit the correct per-skin CSS variables regardless of their DOM position.
570
+
571
+ ### Deprecated
572
+ - `<Sidebar drawerWidth="280px">` — use `<Sidebar defaultWidth={280}>` (number, pixels). The old string prop still works but will be removed in a future major release.
573
+
574
+ ## [3.0.0] — 2026-06-12
575
+
576
+ ### Added
577
+ - **`DockableDesktopProvider`** — Composite provider that wraps `WindowManagerProvider` + `PanelProvider` in the correct order. Drop-in replacement for manually nesting both providers.
578
+ - **`usePanelId()` hook** — Any component rendered inside a panel can call `usePanelId()` to discover its own panel instance ID — no prop needed.
579
+ - **State selectors** — `useWindowManagerState()` now accepts an optional selector function. Components only re-render when the selected slice changes.
580
+ - **Lifecycle callbacks** — `WorkspaceClient` exposes `onPanelOpen`, `onPanelClose`, `onPanelMinimize`, `onPanelRestore` convenience methods.
581
+ - **Typed event bus** — `WorkspaceClient<TUserEvents>` is now generic; `publish` and `subscribe` are fully typed when a user-supplied event map is provided.
582
+ - **Pending-call queue** — Calls to `client.openPanel()` etc. before provider mounts are queued and replayed automatically.
583
+ - **"Forgot `client` prop" warning** — Development warning when a `WorkspaceClient` has queued calls but no provider connects within 1 second.
584
+
585
+ ### Fixed
586
+ - **StrictMode compatibility** — `focusPanel` is now idempotent; calling it twice no longer double-increments z-index. `WorkspaceClient` guards against StrictMode's double `_connect` cycle.
587
+ - **CSS height warning** — `console.warn` fires in development when the workspace container height is near zero (missing `height: 100%` CSS).
588
+ - **Missing-client error** — Upgraded from `console.warn` (dev-only) to `console.error` (always). Fires after 5 s in production, 1 s in development.
589
+
590
+ ## [2.0.0] — 2026-06-12
591
+
592
+ ### Added
593
+ - **`focusPanel(id)`** — Unified activate method for floating and docked panels. Works correctly for both floating windows (z-index focus) and docked panels (tab selection).
594
+ - **`isOpen(id): boolean`** — Query whether a panel is currently open.
595
+ - **`getOpenPanelIds(): string[]`** — List all open panel IDs.
596
+ - **Unregistered panel warning** — `console.warn` when `openPanel` references an unregistered component key.
597
+ - **CSS peer-dep detection** — Development warning when the `replace-react-contexify` stylesheet is not detected.
598
+
599
+ ### Changed
600
+ - **`bringToFront` renamed to `focusPanel`** — `bringToFront` was misleading for docked panels (it selects a tab, not a z-index). The new unified method is `focusPanel`.
601
+
602
+ ### Removed
603
+ - **`setActivePanel`** — Removed from public `WindowActions`. Was an internal tab-focus primitive that leaked into the public interface. Use `focusPanel` instead.
604
+
605
+ ---
606
+
607
+ [Unreleased]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.4.0...HEAD
608
+ [7.4.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.3.0...v7.4.0
609
+ [7.3.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.2.0...v7.3.0
610
+ [7.2.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.1.3...v7.2.0
611
+ [7.1.3]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.1.2...v7.1.3
612
+ [7.1.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.1.1...v7.1.2
613
+ [7.1.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.1.0...v7.1.1
614
+ [7.1.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.0.1...v7.1.0
615
+ [7.0.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v7.0.0...v7.0.1
616
+ [7.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.4.0...v7.0.0
617
+ [6.4.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.3.2...v6.4.0
618
+ [6.3.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.3.1...v6.3.2
619
+ [6.3.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.3.0...v6.3.1
620
+ [6.3.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.2.0...v6.3.0
621
+ [6.1.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.0.1...v6.1.0
622
+ [6.0.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v6.0.0...v6.0.1
623
+ [6.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.4.0...v6.0.0
624
+ [5.4.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.5...v5.4.0
625
+ [5.3.5]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.4...v5.3.5
626
+ [5.3.4]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.3...v5.3.4
627
+ [5.3.3]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.2...v5.3.3
628
+ [5.3.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.1...v5.3.2
629
+ [5.3.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.3.0...v5.3.1
630
+ [5.3.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.2.2...v5.3.0
631
+ [5.2.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.2.1...v5.2.2
632
+ [5.2.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.2.0...v5.2.1
633
+ [5.2.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.1.4...v5.2.0
634
+ [5.1.4]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.1.3...v5.1.4
635
+ [5.1.3]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.1.2...v5.1.3
636
+ [5.1.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.1.1...v5.1.2
637
+ [5.1.1]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.1.0...v5.1.1
638
+ [5.1.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v5.0.0...v5.1.0
639
+ [5.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v4.3.0...v5.0.0
640
+ [4.3.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v4.2.2...v4.3.0
641
+ [4.2.2]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v4.2.1...v4.2.2
642
+ [4.2.0]: https://github.com/felipecarrillo100/react-dockable-desktop/compare/v4.0.0...v4.2.0
643
+ [4.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/releases/tag/v4.0.0
644
+ [3.2.0]: https://github.com/felipecarrillo100/react-dockable-desktop/releases/tag/v3.2.0
645
+ [3.1.0]: https://github.com/felipecarrillo100/react-dockable-desktop/releases/tag/v3.1.0
646
+ [3.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/releases/tag/v3.0.0
647
+ [2.0.0]: https://github.com/felipecarrillo100/react-dockable-desktop/releases/tag/v2.0.0