@deepseek-ai/dsh-client-ui-dockkit 0.2.1-rc.4 → 0.2.2-alpha.2

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

@@ -25,9 +25,9 @@ export interface DockSurfaceProps {
      */
     readonly canAddTab?: (paneId: PaneId) => boolean;
     /**
-     * Whether a tab draws its close control and its menu's close item. Called
+     * Whether a tab may close via its close control, menu item, or middle click. Called
      * per rendered chip on every render; omit to keep every tab closable.
-     * `false` removes both routes without moving the chip: the close control
+     * `false` blocks these 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.
      */

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

@@ -1,4 +1,4 @@
-import type { PointerEvent as ReactPointerEvent, ReactNode } from 'react';
+import type { CSSProperties, PointerEvent as ReactPointerEvent, ReactNode } from 'react';
 import type { DockIntents, DockLabels, TabRenderer } from '../contract/adapter.ts';
 import type { FloatRect, LayoutState, PaneId, TabId, TabRecord } from '../contract/types.ts';
 /** The layout whose `floats` this layer draws. */
@@ -12,11 +12,25 @@ export interface FloatLayerProps {
     /** The panel header's title content; omit to show the record's `title` text (see `DockSurfaceProps`). */
     readonly renderTabTitle?: TabRenderer;
 }
+/**
+ * Inline position of a floating panel. A gesture or return draws it exactly at
+ * `rect`. At rest the panel only publishes `rect` to the `.float` rule, which
+ * clamps it into the viewport and below the caption floor, so a stale viewport
+ * reading in `useFloatGestures` still leaves the panel inside.
+ * @param rect - the rectangle to draw.
+ * @param lifted - whether a gesture or return is drawing the panel.
+ * @returns the panel's inline position and size.
+ */
+export declare function floatStyle(rect: FloatRect, lifted: boolean): CSSProperties;
 /**
  * Shared move/resize gestures; changing layout mode never owns the content DOM.
+ * Panels draw at their stored rectangle projected into the viewport, so a
+ * shrinking window pushes them in without recording anything. A move past an
+ * edge draws with resistance; its release records the legal rectangle and the
+ * panel springs there from where it was drawn.
  * @param state - committed layout and float stacking order.
  * @param intents - gesture settlements.
- * @returns the current preview and focus/gesture callbacks.
+ * @returns the current preview, the rectangle to draw per panel, and focus/gesture callbacks.
  */
 export declare function useFloatGestures(state: LayoutState, intents: DockIntents): {
     preview: {
@@ -25,6 +39,7 @@ export declare function useFloatGestures(state: LayoutState, intents: DockIntent
     } | undefined;
     raise: (paneId: PaneId) => void;
     drag: (mode: "move" | "resize", paneId: PaneId, event: ReactPointerEvent<HTMLElement>) => void;
+    rectOf: (paneId: PaneId, stored: FloatRect) => FloatRect;
 };
 /**
  * Header-only controls, usable above either retained or visibility-mounted bodies.

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import type { TabRenderer } from '../contract/adapter.ts';
+import type { TabRecord } from '../contract/types.ts';
+/** One tab's body, re-rendered only when `renderTab` or `tab` is a new object. */
+export declare const TabBody: import("react").MemoExoticComponent<({ tab, renderTab }: {
+    readonly tab: TabRecord;
+    readonly renderTab: TabRenderer;
+}) => ReactNode>;
+//# sourceMappingURL=TabBody.d.ts.map

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

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { LayoutState, PaneNode } from '../contract/types.ts';
+import type { LayoutState, PaneId, PaneNode } from '../contract/types.ts';
 import type { PaneCallbacks } from './render.ts';
 /** A pane and the live layout it reads its tabs from. */
 export interface TabPanelProps {
@@ -7,10 +7,21 @@ export interface TabPanelProps {
     readonly pane: PaneNode;
     readonly callbacks: PaneCallbacks;
 }
-/** @param props - pane state and gestures. @returns its tab strip without a content container. */
-export declare function TabStrip({ state, pane, callbacks }: TabPanelProps): ReactNode;
+/** A tab strip and where it reads and records its pane's chip-box offset. */
+interface TabStripProps extends TabPanelProps {
+    /**
+     * Chip-box offsets by pane, shared by the strips that replace one another
+     * as a pane's selected tab changes. Keys are valid within one layout only,
+     * and entries outlive their panes. Omitted where no strip continues from
+     * another's position.
+     */
+    readonly offsets?: Map<PaneId, number>;
+}
+/** @param props - pane state, gestures and shared offsets. @returns its tab strip without a content container. */
+export declare function TabStrip({ state, pane, callbacks, offsets }: TabStripProps): ReactNode;
 /** @param props - target pane and drag preview. @returns body-local drop feedback, or nothing. */
 export declare function PaneDropHints({ pane, callbacks }: Pick<TabPanelProps, 'pane' | 'callbacks'>): ReactNode;
 /** @param props - pane state and gestures. @returns one pane in the recursive, visibility-mounted layout. */
 export declare function TabPanel({ state, pane, callbacks }: TabPanelProps): ReactNode;
+export {};
 //# sourceMappingURL=TabPanel.d.ts.map

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

@@ -25,7 +25,7 @@ export interface PaneCallbacks {
     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. */
+    /** Whether a tab may close via its close control, menu item, or middle click. */
     readonly canCloseTab: (tabId: TabId) => boolean;
     /** Live drop preview, or `undefined` while nothing is being dragged. */
     readonly dropTarget: DropTarget | undefined;

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

@@ -43,7 +43,11 @@ export interface DockLabels {
 }
 /**
  * Renders one tab's body. The embedder dispatches on `tab.kind`, which is the
- * only place that string carries meaning.
+ * only place that string carries meaning. As `renderTab`, the kit calls it
+ * again only when the renderer or the tab record is a new object and reuses the
+ * previous body across its own re-renders, such as a gesture's frames: the body
+ * must follow from `tab` and the values the renderer captures, and any other
+ * input reaches it through a new renderer or the body's own hooks and context.
  */
 export type TabRenderer = (tab: TabRecord) => ReactNode;
 /**

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

@@ -151,6 +151,52 @@ export declare function movedRect(rect: FloatRect, dx: number, dy: number): Floa
  * @returns the resized rectangle; the origin is unchanged.
  */
 export declare function resizedRect(rect: FloatRect, dx: number, dy: number, min: Size): FloatRect;
+/**
+ * The viewport region floating panels stay inside: `[0, width]` horizontally and
+ * `[top, height]` vertically, where `top` keeps the header clear of window chrome.
+ */
+export interface FloatBounds {
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** How far past an edge the resistance lets a dragged panel travel, at most, in CSS pixels. */
+export declare const FLOAT_RESISTANCE = 120;
+/**
+ * The nearest rectangle that lies inside the bounds, per axis. A panel larger
+ * than the bounds on an axis takes the bounds' size on it, so its header
+ * controls and resize corner stay reachable.
+ * @param rect - any rectangle, possibly outside the bounds.
+ * @param bounds - the viewport region.
+ * @returns the rectangle moved inside the bounds, its size capped by them.
+ */
+export declare function legalFloatRect(rect: FloatRect, bounds: FloatBounds): FloatRect;
+/**
+ * Where a dragged panel draws when the pointer has taken it past an edge: the
+ * legal rectangle plus a resisted share of the overflow on each axis.
+ * @param desired - the rectangle the pointer travel asks for.
+ * @param bounds - the viewport region.
+ * @returns the drawn rectangle at the legal size; equal to `desired` while it is legal.
+ */
+export declare function resistedRect(desired: FloatRect, bounds: FloatBounds): FloatRect;
+/**
+ * The rectangle a drag must start from so that zero pointer travel draws
+ * `drawn`, the inverse of `resistedRect`: a press on a panel still outside the
+ * bounds picks it up where it is.
+ * @param drawn - where the panel is drawn now.
+ * @param bounds - the viewport region.
+ * @returns the start rectangle at the legal size; equal to `drawn` while it is legal.
+ */
+export declare function unresistedRect(drawn: FloatRect, bounds: FloatBounds): FloatRect;
+/**
+ * A resized rectangle whose bottom-right corner stays inside the bounds, never
+ * below the minimum size.
+ * @param rect - the resized rectangle; its origin may lie outside the bounds.
+ * @param bounds - the viewport region.
+ * @param min - smallest size the panel may take.
+ * @returns the rectangle with its size capped by the bounds.
+ */
+export declare function boundedResize(rect: FloatRect, bounds: FloatBounds, min: Size): FloatRect;
 /**
  * Where a panel should appear when a tab is dropped outside the docked area.
  * @param x - drop point x.

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

@@ -0,0 +1,47 @@
+/**
+ * The spring a floating panel follows back inside the viewport after a release
+ * past an edge. Pure and clock-free: the caller supplies each frame's elapsed
+ * time, so trajectories are deterministic for a given sequence of frames.
+ */
+/** One axis of a spring: where it is and how fast it moves, in CSS pixels and pixels per second. */
+export interface SpringAxis {
+    readonly position: number;
+    readonly velocity: number;
+}
+/** Fastest release velocity a return starts with, in pixels per second. */
+export declare const SPRING_MAX_VELOCITY = 1500;
+/** A return ends at its target after this long even if it is still moving. */
+export declare const SPRING_DEADLINE_MS = 900;
+/** A frame longer than this is clamped, so a slow frame cannot inject a jump. */
+export declare const SPRING_MAX_FRAME_MS = 64;
+/** A gap longer than this (sleep, a stalled tab) ends the return at its target instead of animating catch-up. */
+export declare const SPRING_STALL_MS = 250;
+/**
+ * Advance one axis by an elapsed time, in equal substeps no longer than `SUBSTEP`
+ * (semi-implicit Euler).
+ * @param axis - the axis state.
+ * @param target - the position the spring pulls toward.
+ * @param dtSeconds - elapsed time, already clamped by the caller.
+ * @returns the advanced state.
+ */
+export declare function stepSpring(axis: SpringAxis, target: number, dtSeconds: number): SpringAxis;
+/**
+ * The velocity an axis starts its return with. An axis already at its target
+ * keeps still. Outward speed is capped at `omega0 * (reach - |offset|)`: the
+ * spring carries a start offset `d` and speed `v` at most `d + 0.46 * v / omega0`
+ * from its target, so the whole return stays within `reach`.
+ * @param position - where the axis is drawn at release.
+ * @param target - the position the spring pulls toward.
+ * @param velocity - the drawn release velocity, in pixels per second.
+ * @param reach - the farthest the return may be from the target.
+ * @returns the starting velocity.
+ */
+export declare function launchVelocity(position: number, target: number, velocity: number, reach: number): number;
+/**
+ * Whether an axis has come to rest at its target.
+ * @param axis - the axis state.
+ * @param target - the spring's target.
+ * @returns true within `REST_DISTANCE` of the target and slower than `REST_SPEED`.
+ */
+export declare function springSettled(axis: SpringAxis, target: number): boolean;
+//# sourceMappingURL=spring.d.ts.map

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.2.1-rc.4",
+  "version": "0.2.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -23,9 +23,9 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5",
-    "@deepseek-ai/dsh-brand": "0.2.1-rc.4",
-    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-rc.4",
+    "@deepseek-ai/cordis": "~4.0.6-alpha.1",
+    "@deepseek-ai/dsh-brand": "0.2.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.2-alpha.2",
     "@testing-library/react": "^16.3.3",
     "react-dom": "^18.2.0",
     "react": "^18.2.0",
@@ -37,6 +37,6 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.5"
+    "@deepseek-ai/cordis": "~4.0.6-alpha.1"
   }
 }