vue-dockable-desktop 1.0.0

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

@@ -0,0 +1,51 @@
+/**
+ * The drawer: one pane per mounted tab, only the open one displayed.
+ *
+ * Panes are hidden with `display: none` rather than unmounted, which is what makes
+ * `preserveState` mean anything — and why a tab that asked for neither `eagerMount` nor
+ * `preserveState` is dropped from the mounted set when the drawer closes.
+ */
+import type { SidebarTab } from '../core/sidebarTypes';
+type __VLS_Props = {
+    tabs: SidebarTab[];
+    activeTabId: string | null;
+    position: 'left' | 'right';
+    open: boolean;
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+    /** Suppress the library's own header for every tab. */
+    headerOverridden: boolean;
+    showCloseButton: boolean;
+    /** No transition while a resize drag is in flight, or the drawer lags the pointer. */
+    resizing: boolean;
+};
+declare var __VLS_1: {
+    tab: SidebarTab;
+    close: () => void;
+    open: () => void;
+}, __VLS_13: `tab-${string}`, __VLS_14: {
+    tab: SidebarTab;
+    close: () => void;
+    open: () => void;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_13>]?: (props: typeof __VLS_14) => any;
+} & {
+    header?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    open: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,22 @@
+/**
+ * The activity strip: header entries, the tab buttons, footer entries.
+ *
+ * Its own component so the left and right arrangements share one implementation. Writing it
+ * twice inside the parent is how the two sides drift apart.
+ */
+import type { SidebarRailEntry, SidebarTab } from '../core/sidebarTypes';
+type __VLS_Props = {
+    tabs: SidebarTab[];
+    header: SidebarRailEntry[];
+    footer: SidebarRailEntry[];
+    activeTabId: string | null;
+    position: 'left' | 'right';
+    visible: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    tabId: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    open: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onOpen?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,17 @@
+import type { PanelDomCache } from '../core/panelDom';
+export type TaskbarVisibility = 'always' | 'compact' | 'autohide';
+type __VLS_Props = {
+    visibility?: TaskbarVisibility;
+    cache: PanelDomCache;
+    /** Fallback icon for panels that register none. */
+    defaultIcon?: unknown;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    contextMenu: (panelId: string, event: MouseEvent | PointerEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onContextMenu?: ((panelId: string, event: MouseEvent | PointerEvent) => any) | undefined;
+}>, {
+    visibility: TaskbarVisibility;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,24 @@
+import type { PanelDomCache } from '../core/panelDom';
+type __VLS_Props = {
+    panelId: string;
+    /** The icon's on-screen rect, so the preview can sit above it. */
+    anchor: {
+        left: number;
+        top: number;
+        width: number;
+    };
+    cache: PanelDomCache;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    restore: () => any;
+    dismiss: () => any;
+    keep: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onRestore?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
+    onKeep?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,8 @@
+/** The built-in per-type icons. Replaced per toast by `toast(msg, { icon })`. */
+import type { ToastType } from '../core/toast';
+type __VLS_Props = {
+    type: ToastType;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,18 @@
+import type { ToastRecord } from '../core/toast';
+type __VLS_Props = {
+    toast: ToastRecord;
+    /** A left-hand container slides in from the other side. */
+    isLeft: boolean;
+    showProgress: boolean;
+    pauseOnHover: boolean;
+    animation: 'slide' | 'fade' | 'none';
+    defaultDuration: number;
+    defaultClosable: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    exited: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onExited?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,36 @@
+import type { ToastAdapter, ToastPosition } from '../core/toast';
+type __VLS_Props = {
+    /** @default 'top-right' */
+    position?: ToastPosition;
+    /** How many show at once. The rest wait. @default 3 */
+    maxVisible?: number;
+    /** Auto-dismiss delay in ms; `0` makes every toast sticky. @default 5000 */
+    defaultDuration?: number;
+    /** @default true */
+    defaultClosable?: boolean;
+    /** Hold the timer while the pointer is over a toast. @default true */
+    pauseOnHover?: boolean;
+    /** @default 'slide' */
+    animation?: 'slide' | 'fade' | 'none';
+    /** Put the newest toast at the top of the stack. @default false */
+    newestOnTop?: boolean;
+    /** A countdown bar along the bottom of each toast. @default false */
+    progressBar?: boolean;
+    /** Card width in pixels. @default 320 */
+    width?: number;
+    /** Hand every `toast.*` call to another library instead. */
+    adapter?: ToastAdapter;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    width: number;
+    position: ToastPosition;
+    animation: "slide" | "fade" | "none";
+    pauseOnHover: boolean;
+    defaultDuration: number;
+    defaultClosable: boolean;
+    maxVisible: number;
+    newestOnTop: boolean;
+    progressBar: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,20 @@
+import type { ToolbarItem } from '../core/toolbarTypes';
+type __VLS_Props = {
+    /** Which edge to attach to; also decides the strip's orientation. @default 'left' */
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    items: ToolbarItem[];
+};
+type __VLS_ModelProps = {
+    /** Collapse the strip to nothing. State is kept — items are not unmounted. */
+    'visible'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+}>, {
+    position: "left" | "right" | "top" | "bottom";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,25 @@
+/** An icon button for a `<VddPanelToolbar>`. The icon is a slot, so anything renders. */
+type __VLS_Props = {
+    /** Tooltip and accessible name. */
+    title?: string;
+    disabled?: boolean;
+    /** Overrides the toolbar's own `buttonVariant`. */
+    variant?: 'ghost' | 'soft' | 'outlined' | 'filled';
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,8 @@
+import type { ToolbarGroupItem } from '../core/toolbarTypes';
+type __VLS_Props = {
+    item: ToolbarGroupItem;
+    position: 'left' | 'right' | 'top' | 'bottom';
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,27 @@
+import type { Component } from 'vue';
+/** One row in the dropdown. */
+export interface SearchResult {
+    id: string;
+    label: string;
+    /** Secondary text, below the label. */
+    description?: string;
+    /** Groups results under a heading. */
+    group?: string;
+    icon?: Component;
+}
+type __VLS_Props = {
+    placeholder?: string;
+    /** Called on each change, debounced. Return results, or a promise of them. */
+    search: (query: string, signal: AbortSignal) => SearchResult[] | Promise<SearchResult[]>;
+    /** Debounce in ms. @default 300 */
+    debounce?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (result: SearchResult) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((result: SearchResult) => any) | undefined;
+}>, {
+    debounce: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,32 @@
+/**
+ * A two-state icon button for a `<VddPanelToolbar>`.
+ *
+ * rdd took `active` plus `onToggle` and left flipping it to the caller. `v-model:active` is
+ * the same thing without the boilerplate, and still controllable: bind it and you own it.
+ */
+type __VLS_Props = {
+    title?: string;
+    disabled?: boolean;
+    variant?: 'ghost' | 'soft' | 'outlined' | 'filled';
+};
+type __VLS_ModelProps = {
+    'active'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:active": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:active"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,8 @@
+import type { LayoutNode } from '../types';
+type __VLS_Props = {
+    node: LayoutNode;
+    path: number[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/useColorScheme.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedRef } from 'vue';
+/** What the workspace is currently rendering as. */
+export type ColorScheme = 'dark' | 'light';
+/**
+ * The workspace's current colour scheme, as a ref that follows it.
+ *
+ * `<VddDesktop>` mirrors the scheme onto `document.documentElement` as
+ * `data-color-scheme`; this watches that attribute. For panel content that has to match —
+ * a map's tile layer, an embedded editor's theme, a chart's palette.
+ *
+ * ```ts
+ * const scheme = useColorScheme()
+ * watch(scheme, s => map.setStyle(s === 'dark' ? darkStyle : lightStyle))
+ * ```
+ *
+ * Anything other than `'light'` reads as `'dark'`, including a missing attribute, so there is
+ * no third state to handle.
+ */
+export declare function useColorScheme(): ComputedRef<ColorScheme>;

package/dist/composables/useContextMenu.d.ts

@@ -0,0 +1,29 @@
+import type { ContextMenuItem, ShowContextMenuOptions } from '../core/contextMenu';
+/**
+ * Open a context menu from anywhere.
+ *
+ * ```ts
+ * const showMenu = useContextMenu()
+ * showMenu({ event, items: [{ label: 'Rename', action: rename }] })
+ * ```
+ *
+ * Works wherever `useWorkspace()` works, including outside the component tree — the menu
+ * request is state, and `<VddContextMenu>` renders what is pending.
+ */
+export declare function useContextMenu(): (options: ShowContextMenuOptions) => void;
+/**
+ * Contribute items to *this panel's* own context menu, from inside the panel.
+ *
+ * Pass a getter: it is read each time the menu opens, so items that enable, disable, check
+ * or disappear with the panel's state need no extra wiring.
+ *
+ * ```ts
+ * usePanelContextMenu(() => [
+ *   { label: 'Save', action: save },
+ *   { label: 'Revert', action: revert, disabled: !dirty.value },
+ * ])
+ * ```
+ *
+ * Registered in `setup` and disposed with the component — nothing to unsubscribe.
+ */
+export declare function usePanelContextMenu(items: () => ContextMenuItem[]): void;

package/dist/composables/useContributions.d.ts

@@ -0,0 +1,48 @@
+import type { Component, ComputedRef, MaybeRefOrGetter } from 'vue';
+import type { PanelContribution } from '../core/contributions';
+import type { SidebarTab } from '../core/sidebarTypes';
+import type { ToolbarItem } from '../core/toolbarTypes';
+/**
+ * Publish this panel's toolbar items and sidebar sections, for the shell to surface while
+ * this panel is the active one.
+ *
+ * Pass a getter or a ref, not a plain object: the contribution is re-published whenever it
+ * changes, so items that enable, check or disappear with the panel's own state need no extra
+ * wiring.
+ *
+ * ```ts
+ * const tool = ref<'pan' | 'draw'>('pan')
+ * usePanelContribution(() => ({
+ *   toolbarItems: [
+ *     { type: 'toggle', id: 'draw', label: 'Draw', icon: Pencil,
+ *       active: tool.value === 'draw', onToggle: v => (tool.value = v ? 'draw' : 'pan') },
+ *   ],
+ *   sidebarSections: [{ id: 'layers', label: 'Layers', component: LayerList }],
+ * }))
+ * ```
+ *
+ * rdd asked callers to memoise the object themselves, and to call the hook on every render,
+ * because a new object literal each render meant republishing each render. A getter makes
+ * that the framework's problem instead of the caller's.
+ *
+ * Registered in `setup` and withdrawn with the component — nothing to unsubscribe.
+ */
+export declare function usePanelContribution(contribution: MaybeRefOrGetter<PanelContribution>): void;
+/**
+ * What the active panel has published, or `null`.
+ *
+ * For the app shell to merge into its own `<VddToolbar :items>` and `<VddSidebar :tabs>`.
+ * Nothing is merged automatically: the library does not know what a contributed item means
+ * for your domain, or where in your toolbar it belongs.
+ */
+export declare function useActiveContribution(): ComputedRef<PanelContribution | null>;
+/**
+ * A static toolbar list with the active panel's contributed items appended behind a
+ * separator, as a `computed`.
+ *
+ * `mergeToolbarItems` is the plain function underneath, for when the merge position or the
+ * separator needs to be different.
+ */
+export declare function useMergedToolbarItems(staticItems: MaybeRefOrGetter<ToolbarItem[]>): ComputedRef<ToolbarItem[]>;
+/** A static tab list with the active panel's contributed sections appended, as a `computed`. */
+export declare function useMergedSidebarTabs(staticTabs: MaybeRefOrGetter<SidebarTab[]>, fallbackIcon?: Component): ComputedRef<SidebarTab[]>;

package/dist/composables/useDragDock.d.ts

@@ -0,0 +1,59 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { DropPosition, FloatAnchor, SplitDirection } from '../types';
+import type { Workspace } from '../core/workspace';
+/** How long a touch must rest before it becomes a drag. */
+export declare const LONG_PRESS_MS = 300;
+/** How far a touch may wander before the long press is abandoned. */
+export declare const CANCEL_MOVE_PX = 8;
+/** Which tab a dragged panel would be inserted next to. */
+export interface TabTarget {
+    leafId: string;
+    panelId: string;
+    index: number;
+    side: 'left' | 'right';
+}
+export interface DragDock {
+    /** The panel being dragged, or `null`. */
+    draggedId: Ref<string | null>;
+    /** Pointer position, for the ghost. */
+    pointer: Ref<{
+        x: number;
+        y: number;
+    }>;
+    /** The armed leaf cross target. */
+    zone: Ref<{
+        leafId: string;
+        position: DropPosition;
+    } | null>;
+    /** The armed workspace edge. */
+    edge: Ref<SplitDirection | null>;
+    /** The armed corner anchor. */
+    corner: Ref<FloatAnchor | null>;
+    /** The armed tab insertion point. */
+    tab: Ref<TabTarget | null>;
+    /** True while a gesture is in progress. */
+    dragging: ComputedRef<boolean>;
+    startTabDrag: (panelId: string, event: PointerEvent, onLongPressWithoutDrag?: (e: PointerEvent) => void) => void;
+    /** Begin a gesture that another component drives (a floating window's title bar). */
+    beginDrag: (panelId: string) => void;
+    /**
+     * Update the pointer and re-resolve the armed target by hit-testing.
+     *
+     * Needed whenever the gesture holds pointer capture — a captured pointer routes every
+     * event to the capturing element, so the drop zones never receive `pointerenter`. The
+     * dragged window sets `pointer-events: none` on itself, so the zones beneath it are what
+     * the hit test finds.
+     */
+    trackPointer: (x: number, y: number) => void;
+    hoverZone: (leafId: string, position: DropPosition | null) => void;
+    hoverEdge: (edge: SplitDirection | null) => void;
+    hoverCorner: (corner: FloatAnchor | null) => void;
+    hoverTab: (target: TabTarget | null) => void;
+    /** Finish a gesture started elsewhere (a floating window's title bar). */
+    finishDrag: (panelId: string, event: PointerEvent) => void;
+    cancel: () => void;
+}
+/** @internal */
+export declare function provideDragDock(ws: Workspace<never>): DragDock;
+/** @internal */
+export declare function useDragDock(): DragDock | null;

package/dist/composables/useOverlayHost.d.ts

@@ -0,0 +1,30 @@
+import type { ComputedRef, Component, MaybeRefOrGetter } from 'vue';
+import type { OverlayInstance } from '../core/overlays';
+/**
+ * Everything a rendered side panel or modal needs, in one place.
+ *
+ * rdd's `SidePanelRenderer` and `ModalStackRenderer` each carried their own copy of this —
+ * the close sequence, the dirty-confirmation modal, the title asterisk, the `setDirty` and
+ * `setTitle` plumbing, the Escape handler. Thirty-five of those lines were character-for-
+ * character identical, which is how two containers come to disagree about what closing a
+ * dirty panel does. Here the two components differ only in their chrome.
+ *
+ * **Escape routing** lives here too, and is the reason it can be stated once: Escape belongs
+ * to the topmost modal, and reaches a drawer only when no modal is open. rdd expressed the
+ * same rule twice, in two different shapes (`modals.length === 0` in one,
+ * `isTopmost` in the other).
+ */
+export declare function useOverlayHost(instance: MaybeRefOrGetter<OverlayInstance>): {
+    /** The instance's title, resolved through the formatter, with a trailing `*` when dirty. */
+    displayTitle: ComputedRef<string>;
+    /** Whether Escape and a backdrop click should close this instance. */
+    dismissible: ComputedRef<boolean>;
+    /** The icon to show in the header: the live one set from inside, else the open-time one. */
+    icon: ComputedRef<Component | null>;
+    /** Close, honouring the close guard and dirty state. */
+    close: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    /** `padding` for the body, or `undefined` to leave it to the stylesheet. */
+    bodyPadding: ComputedRef<string | undefined>;
+};

package/dist/composables/useOverlays.d.ts

@@ -0,0 +1,51 @@
+import type { Component, ComputedRef } from 'vue';
+import type { ModalOptions, OverlayInstance, SidePanelOptions } from '../core/overlays';
+/**
+ * The modal stack.
+ *
+ * ```ts
+ * const { open, close, closeAll, stack } = useModals()
+ * const id = open(EditFeature, { featureId }, { size: 'medium', title: 'Edit' })
+ * ```
+ *
+ * `open` returns the instance id, which is what `close(id)` takes. Modals stack, so opening
+ * one never closes another.
+ *
+ * Every one of these is also reachable as `workspace.overlays.*` without a component, which
+ * is the usual case for a confirmation raised by a service.
+ */
+export declare function useModals(): {
+    /** Bottom to top — the last entry is the topmost. */
+    stack: ComputedRef<OverlayInstance[]>;
+    /** The topmost modal, or `null`. */
+    topmost: ComputedRef<OverlayInstance | null>;
+    open: (component: Component, props?: Record<string, unknown>, options?: ModalOptions) => string;
+    /** Close, honouring the modal's close guard and dirty state. */
+    close: (id: string, options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    closeAll: () => void;
+};
+/**
+ * The two side drawers.
+ *
+ * ```ts
+ * const { openLeft, openRight, close, left, right } = useSidePanels()
+ * await openLeft(LayerList, { layers }, { title: 'Layers', width: 320 })
+ * ```
+ *
+ * Each side holds one panel, so opening is also closing whatever was there — which is why
+ * `openLeft`/`openRight` are async and resolve to `null` when the occupant's close guard
+ * refuses. A synchronous return would have to either ignore the guard or lie about the id.
+ */
+export declare function useSidePanels(): {
+    left: ComputedRef<OverlayInstance | null>;
+    right: ComputedRef<OverlayInstance | null>;
+    openLeft: (component: Component, props?: Record<string, unknown>, options?: SidePanelOptions) => Promise<string | null>;
+    openRight: (component: Component, props?: Record<string, unknown>, options?: SidePanelOptions) => Promise<string | null>;
+    close: (id: string, options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    /** Close both drawers, leaving the modal stack alone. */
+    closeAll: () => void;
+};