vue-dockable-desktop 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -11,6 +11,54 @@ correspondence lives, alongside the feature-by-feature map in [docs/PARITY.md](d
 
 ## [Unreleased]
 
+## [1.0.1] — 2026-09-17
+
+**Parity: react-dockable-desktop 6.3.0.**
+
+### Fixed
+
+- **A widget opened through `useFloatingWidgets()` discarded every placement gesture.** Dropping
+  a managed widget on another corner returned it to the corner `open()` named, and a stretched
+  one lost its stretch as soon as any other widget opened or closed. Template-declared widgets
+  and plain resizes were unaffected. Reported by a user.
+
+  `<VddPanelOverlay>` bound `placement` — a `defineModel` — as a fresh `{ anchor, stretch }`
+  literal with no `@update:placement`, and Vue re-syncs a model from its prop whenever the
+  prop's *identity* changes. Every render of the overlay therefore reset the widget, and the
+  overlay re-renders on exactly the wrong events: a drop clears `draggingId` in the same
+  function that applies the placement, and opening a widget bumps `managedVersion`.
+
+  The overlay now keeps a placement record per widget id and writes gestures straight back into
+  it. `anchor`, `stretch`, `width` and `height` on `open()` are **initial values** — as rdd's
+  `defaultAnchor`/`defaultStretch` are — so `open()` on an id that is already open refreshes its
+  content and leaves the widget where the user put it, and `close()` then `open()` is what
+  resets placement. No public API changed.
+
+  A port regression: rdd never makes the anchor controllable, and the only placement value it
+  lets a caller control is a primitive, so identity churn cannot arise there. Recorded as **R1**
+  in [`docs/PARITY.md`](docs/PARITY.md), with the underlying `defineModel` constraint amended
+  into [ADR 0005](docs/decisions/0005-vmodel.md). Pinned by PO31–PO35, four M14 gate rules, and
+  a real pointer drag in the demo's browser walkthrough — the gesture path into an overlay-owned
+  widget that no layer of either library's verification had ever driven.
+
+- **In the demo, no camera marker on the main map could be clicked**, though the legend invited
+  it: a decorative polygon added after the markers covered the whole cluster and swallowed every
+  click. It is `interactive: false` now. Found by the new browser assertion trying to open a
+  widget the way a user does.
+
+### Changed
+
+- The demo's camera widgets are opened through `useFloatingWidgets()` instead of a `v-for` over
+  `<VddFloatingWidget>`, so the managed path — the one that regressed — is demonstrated and
+  walked by the gate. The M14 capability rule now requires the composable itself rather than
+  accepting `@update:open`, which is what let the demo claim the capability without exercising
+  it.
+- The M11 browser gate's stretch assertion was measuring the wrong thing: it expected a
+  full-width strip to be `panel - 16` and ignored the inline panel toolbars beside it, so a
+  strip that tracked its panel perfectly was reported as having stopped. It now asserts the
+  tracking claim as a delta and measures the toolbar band. No library behaviour was involved —
+  the failure reproduced identically against 1.0.0's source.
+
 ## [1.0.0] — 2026-09-16
 
 **Parity: react-dockable-desktop 6.3.0.**

package/README.md

@@ -34,7 +34,7 @@ npm install vue-dockable-desktop
 
 Requires Vue 3.4+. No other runtime dependencies. The published package is
 [`vue-dockable-desktop`](https://www.npmjs.com/package/vue-dockable-desktop); the public API
-is pinned by `api-surface.json` and covered by 725 tests.
+is pinned by `api-surface.json` and covered by 730 tests.
 
 ## Quick start
 

package/dist/components/VddFloatingWidget.vue.d.ts

@@ -22,6 +22,12 @@ type __VLS_ModelProps = {
      *
      * Bind it and the caller owns placement — which is also the only way to persist it, since the
      * library serialises nothing about inner widgets. Leave it off and the widget keeps its own.
+     *
+     * **If you bind it, the value must be stable or echoed back.** `defineModel` re-syncs from the
+     * prop whenever the prop's *identity* changes, so a fresh object literal — `:placement="{ anchor,
+     * stretch }"` — resets the widget on every render of the parent, with or without a listener, and
+     * gestures appear to work and then revert. Hold it in a `ref` and use `v-model:placement`, or
+     * write the emitted value back into whatever you bound.
      */
     'placement'?: PanelFloatPlacement;
 };

package/dist/core/overlayState.d.ts

@@ -17,9 +17,23 @@ export interface ManagedWidget {
     /** Rendered as the widget's content. */
     component: Component;
     props?: Record<string, unknown>;
+    /**
+     * The corner to dock to **on first open**, not live state.
+     *
+     * Seeded into the overlay's own placement record and owned there afterwards, so a gesture
+     * that moves the widget is not undone the next time the caller's state re-renders — and
+     * `open()` on a widget that is already open refreshes its content without yanking it back
+     * to this corner. `close()` then `open()` is what re-seeds it. rdd draws the same line,
+     * with `defaultAnchor` feeding a `useState`.
+     *
+     * @default 'top-right'
+     */
     anchor?: FloatAnchor;
+    /** Initial width in pixels. @default 320 */
     width?: number;
+    /** Initial height in pixels. @default 240 */
     height?: number;
+    /** Which axes span the panel **on first open**. As `anchor`, a seed rather than live state. */
     stretch?: Stretch | null;
 }
 export interface OverlayStacks {
@@ -48,6 +62,15 @@ export interface PanelOverlayStore {
     managed: Map<string, ManagedWidget>;
     /** Bumped whenever `managed` changes, since a `Map` is not reactive by itself. */
     managedVersion: Ref<number>;
+    /**
+     * Live placement of each managed widget, seeded by {@link PanelOverlayStore.openManaged}
+     * from the widget's own `anchor`/`stretch` and owned here from then on.
+     *
+     * Here rather than inside `<VddFloatingWidget>` because a managed widget's `placement` model
+     * has to be *bound* by the overlay — and a bound model is authoritative on every render, so
+     * whatever the overlay binds has to be the live value rather than a re-derived seed.
+     */
+    managedPlacements: Record<string, PanelFloatPlacement>;
     registerToolbar(position: ToolbarPosition, size: number): void;
     unregisterToolbar(position: ToolbarPosition): void;
     focus(id: string): void;
@@ -58,6 +81,8 @@ export interface PanelOverlayStore {
     closeManaged(id: string): void;
     closeAllManaged(): void;
     managedIds(): string[];
+    /** Record what a gesture did to a managed widget's placement. */
+    setManagedPlacement(id: string, placement: PanelFloatPlacement): void;
 }
 export declare const PANEL_OVERLAY_KEY: InjectionKey<PanelOverlayStore>;
 export declare function createPanelOverlayStore(): PanelOverlayStore;