@deepseek-ai/dsh-client-ui-dockkit 0.1.5-alpha.1 → 0.1.5-alpha.2

package/lib/types/components/DockSurface.d.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from 'react';
 import type { DockIntents, DockLabels, TabMenuExtras, TabRenderer } from '../contract/adapter.ts';
-import type { LayoutState, PaneId } from '../contract/types.ts';
+import type { LayoutState, PaneId, TabId } from '../contract/types.ts';
 import type { HalvesFit } from '../engine/geometry.ts';
 /** What the docked surface needs: the layout, its limits, and the outward contracts. */
 export interface DockSurfaceProps {
@@ -11,8 +11,8 @@ export interface DockSurfaceProps {
      * split control disabled with `labels.splitPaneNarrow` (see README).
      */
     readonly canSplit: boolean;
-    /** Hide the split control when the pane budget is spent; defaults to false. Width-blocked controls remain disabled. */
-    readonly hideSplitAtCapacity?: boolean;
+    /** Hide a blocked split control — pane budget spent or pane too narrow — instead of rendering it disabled; defaults to false. */
+    readonly hideSplitWhenBlocked?: boolean;
     /** Body drop geometry: all edge bands, or left/right halves with whole-pane moves once splitting is unavailable. */
     readonly dropZones?: 'edges' | 'horizontal';
     /** Smallest share a divider may leave a pane; defaults to the kit's fraction. */
@@ -23,6 +23,14 @@ export interface DockSurfaceProps {
      * end controls where they are and the chips as the only shrinking part.
      */
     readonly canAddTab?: (paneId: PaneId) => boolean;
+    /**
+     * Whether a tab draws its close control and its menu's close item. Called
+     * per rendered chip on every render; omit to keep every tab closable.
+     * `false` removes both routes without moving the chip: the close control
+     * paints over the title's end rather than beside it, so the chip is the same
+     * width either way. The menu still opens and carries the embedder's items.
+     */
+    readonly canCloseTab?: (tabId: TabId) => boolean;
     readonly intents: DockIntents;
     readonly labels: DockLabels;
     readonly renderTab: TabRenderer;
@@ -48,5 +56,5 @@ export interface DockSurfaceProps {
     readonly onRoom?: (fits: ReadonlyMap<PaneId, HalvesFit>) => void;
 }
 /** The split tree and the gestures over it. */
-export declare function DockSurface({ state, canSplit, canAddTab, intents, labels, renderTab, renderTabTitle, renderTabMenuItems, chrome, onRoom, dropZones, minPaneFraction, hideSplitAtCapacity, }: DockSurfaceProps): ReactNode;
+export declare function DockSurface({ state, canSplit, canAddTab, canCloseTab, intents, labels, renderTab, renderTabTitle, renderTabMenuItems, chrome, onRoom, dropZones, minPaneFraction, hideSplitWhenBlocked, }: DockSurfaceProps): ReactNode;
 //# sourceMappingURL=DockSurface.d.ts.map

package/lib/types/components/FloatLayer.d.ts

@@ -1,15 +1,17 @@
 import type { ReactNode } from 'react';
 import type { DockIntents, DockLabels, TabRenderer } from '../contract/adapter.ts';
-import type { LayoutState } from '../contract/types.ts';
+import type { LayoutState, TabId } from '../contract/types.ts';
 /** The layout whose `floats` this layer draws. */
 export interface FloatLayerProps {
     readonly state: LayoutState;
     readonly intents: DockIntents;
     readonly labels: DockLabels;
     readonly renderTab: TabRenderer;
+    /** Whether a floating tab offers its close control; defaults to true. Called per tab on every render. */
+    readonly canCloseTab?: (tabId: TabId) => boolean;
     /** The panel header's title content; omit to show the record's `title` text (see `DockSurfaceProps`). */
     readonly renderTabTitle?: TabRenderer;
 }
 /** Every floating panel, in z order. */
-export declare function FloatLayer({ state, intents, labels, renderTab, renderTabTitle }: FloatLayerProps): ReactNode;
+export declare function FloatLayer({ state, intents, labels, renderTab, renderTabTitle, canCloseTab }: FloatLayerProps): ReactNode;
 //# sourceMappingURL=FloatLayer.d.ts.map

package/lib/types/components/TabMenu.d.ts

@@ -5,7 +5,8 @@ export interface TabMenuProps {
     readonly labels: DockLabels;
     /** The control that opened the menu; the menu hangs below its left edge. */
     readonly anchor: HTMLElement;
-    readonly onClose: () => void;
+    /** Close the tab; `undefined` removes the kit's item, leaving the extras only. */
+    readonly onClose: (() => void) | undefined;
     /** Dismiss without acting. */
     readonly onDismiss: () => void;
     /** Embedder items, rendered after the kit's own; absent means none. */

package/lib/types/components/TabTitle.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+/** The title span of a strip chip or a floating panel's header chip. */
+export declare function TabTitle({ children }: {
+    readonly children: ReactNode;
+}): ReactNode;
+//# sourceMappingURL=TabTitle.d.ts.map

package/lib/types/components/measure.d.ts

@@ -15,9 +15,13 @@ export declare function paneElements(root: HTMLElement): readonly (readonly [Pan
 /**
  * Measure every docked pane under `root`.
  * @param root - the docked surface's element.
+ * @param splitHiddenWhenBlocked - whether the embedder hides blocked split
+ * controls (`hideSplitWhenBlocked`); the room rule then leaves the control's
+ * footprint out of each strip's fixed part, so the reading cannot flip with
+ * the control's visibility (see `PaneMeasure.splitControlWidth`).
  * @returns each pane's fit, keyed by pane id.
  */
-export declare function measurePaneFits(root: HTMLElement): ReadonlyMap<PaneId, HalvesFit>;
+export declare function measurePaneFits(root: HTMLElement, splitHiddenWhenBlocked?: boolean): ReadonlyMap<PaneId, HalvesFit>;
 /**
  * One pane's latest reading. A pane the map does not name has not been
  * measured and fits: the rule only blocks on a positive reading.

package/lib/types/components/render.d.ts

@@ -21,10 +21,12 @@ export interface PaneCallbacks {
     readonly onDividerPressed: (splitId: SplitId, index: number, event: ReactPointerEvent<HTMLElement>) => void;
     /** Why a pane cannot split right now, or `undefined` while it can. */
     readonly splitBlock: (paneId: PaneId) => SplitBlock | undefined;
-    /** Hide budget-blocked split controls without hiding width-blocked controls. */
-    readonly hideSplitAtCapacity?: boolean;
+    /** Hide blocked split controls instead of rendering them disabled. */
+    readonly hideSplitWhenBlocked?: boolean;
     /** Whether a pane's strip draws the add control. */
     readonly canAddTab: (paneId: PaneId) => boolean;
+    /** Whether a tab draws its close control and its menu's close item. */
+    readonly canCloseTab: (tabId: TabId) => boolean;
     /** Live drop preview, or `undefined` while nothing is being dragged. */
     readonly dropTarget: DropTarget | undefined;
     /** Show both horizontal landing regions while a body split is being targeted. */

package/lib/types/contract/adapter.d.ts

@@ -30,6 +30,8 @@ export interface DockLabels {
     readonly dockFloat: string;
     /** Close a floating panel. */
     readonly closeFloat: string;
+    /** The drop hint's caption for each body zone a dragged tab can land on. */
+    readonly dropZone: Readonly<Record<DockZone, string>>;
 }
 /**
  * Renders one tab's body. The embedder dispatches on `tab.kind`, which is the
@@ -42,10 +44,12 @@ export type TabRenderer = (tab: TabRecord) => ReactNode;
  *
  * The kit's own item is the close gesture; anything that means something about
  * the tab's content comes from here. An item that acts MUST call `dismiss`,
- * because the menu closes on its own items only.
+ * because the menu closes on its own items only. Every rendered item MUST
+ * carry `role="menuitem"`: the kit probes for that role to dismiss a menu
+ * that would paint empty, so items without it count as an empty menu.
  * @param tab - the tab whose menu is open.
  * @param dismiss - close the menu without acting.
- * @returns the extra items, or nothing.
+ * @returns extra actions with ARIA menuitem, menuitemcheckbox, or menuitemradio roles, or nothing.
  */
 export type TabMenuExtras = (tab: TabRecord, dismiss: () => void) => ReactNode;
 /**

package/lib/types/engine/geometry.d.ts

@@ -60,6 +60,17 @@ export interface PaneMeasure {
     readonly chipsWidth: number;
     /** Width of the fill: free space, not a control. */
     readonly fillWidth: number;
+    /**
+     * Footprint of the rendered split control (its width plus the strip's gap)
+     * for embedders that hide blocked split controls: a half too narrow to
+     * split hides its own control, so the rule leaves the footprint out of the
+     * fixed part. Leaving it out is also what keeps the reading stable — the
+     * control hiding sheds the same footprint from the strip, and a reading
+     * that counted it would flip with the control's visibility and re-render
+     * forever. Absent or 0 keeps the control in the fixed part, for embedders
+     * that render a blocked control disabled.
+     */
+    readonly splitControlWidth?: number;
 }
 /** Pixel minimums the room rule holds each half to. */
 export interface SplitMinimums {
@@ -67,15 +78,16 @@ export interface SplitMinimums {
     readonly divider: number;
     /** One chip at its minimum: the smallest strip that still names a tab. */
     readonly chip: number;
-    /** The smallest body under a strip: one secondary text line inside the body's padding. */
+    /** The smallest body under a strip: one secondary text line inside 12px of the body's own insets. */
     readonly body: number;
 }
 /**
  * The minimums where no computed style can be read, mirroring
- * `dockkit.module.css`: `.splitRow > .divider` is 4px wide; `.tab` is 44px of
- * content plus 10px + 5px of padding (content-box), 59px; the body's 12px
- * padding above and below one 13px secondary line at 1.6 line-height is 45px,
- * held to 48px.
+ * `dockkit.module.css`: `.splitRow > .divider` takes no layout width (its
+ * hairline is painted over the seam); `.tab` is 80px of content plus
+ * 10px + 10px of padding (content-box), 100px; 12px above and below one 13px
+ * secondary line at 1.6 line-height — the inset a body draws for itself, as
+ * `.empty` does — is 45px, held to 48px.
  */
 export declare const SPLIT_MINIMUMS: SplitMinimums;
 /** Whether a pane's two halves after an equal split would each still work. */
@@ -87,9 +99,10 @@ export interface HalvesFit {
 }
 /**
  * The room rule. After an equal split each half must hold what cannot shrink:
- * horizontally the strip's fixed part — its width minus the chip box and the
- * fill, which is the padding, the gaps, and every control that pane draws —
- * plus one chip at its minimum; vertically the strip plus a minimum body. The
+ * horizontally the strip's fixed part — its width minus the chip box, the
+ * fill, and `splitControlWidth`, which is the padding, the gaps, and every
+ * control a half would still draw — plus one chip at its minimum; vertically
+ * the strip plus a minimum body. The
  * borders are what the pane's box exceeds the strip's by. An unmeasured pane
  * (no layout, as under jsdom) fits: the rule only blocks on a positive reading.
  * @param measure - the pane's rectangles.

package/lib/types/engine/planner.d.ts

@@ -128,16 +128,19 @@ export declare function planPlaceTab(state: LayoutState, tabId: TabId, toPaneId:
 /**
  * Resolve a tab release on a pane body: the centre moves the tab in, an edge
  * splits the pane and seats the tab in the new half. A pane's only tab released
- * on that pane changes nothing in either zone: the split would empty the pane
- * and seat the tab beside where it already was.
+ * on that pane's centre changes nothing; released on its edge it splits, and
+ * the factory's tab backfills the pane the drag would otherwise empty — without
+ * a factory that release also changes nothing, since the split would empty the
+ * pane and seat the tab beside where it already was.
  * @param state - current layout.
  * @param mint - id source for a pane an edge release creates.
  * @param tabId - the dragged tab.
  * @param targetPaneId - pane under the pointer.
  * @param zone - dock region the pointer released in.
+ * @param makeTab - builds the tab that backfills a pane its only tab splits away from.
  * @returns the operations, or none when the release changes nothing.
  */
-export declare function planDropTab(state: LayoutState, mint: Mint, tabId: TabId, targetPaneId: PaneId, zone: DockZone): readonly LayoutOp[];
+export declare function planDropTab(state: LayoutState, mint: Mint, tabId: TabId, targetPaneId: PaneId, zone: DockZone, makeTab?: TabFactory): readonly LayoutOp[];
 /**
  * Take a tab out into a floating panel.
  * @param state - current layout.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-dockkit",
   "description": "Docking layout kit: split-tree engine with invertible operations, and the React components that render and drive it (zero cordis)",
-  "version": "0.1.5-alpha.1",
+  "version": "0.1.5-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -22,18 +22,16 @@
     "./package.json": "./package.json"
   },
   "license": "MIT",
-  "dependencies": {
-    "clsx": "^2.0.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  },
   "devDependencies": {
     "@testing-library/react": "^16.1.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "~18.3.0",
     "react-dom": "^18.2.0",
+    "react": "^18.2.0",
+    "clsx": "^2.0.0",
+    "@deepseek-ai/dsh-brand": "^0.1.5-alpha.2",
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-brand": "^0.1.5-alpha.1"
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.5-alpha.2"
   },
   "files": [
     "lib/index.js",