@mintplayer/ng-bootstrap 21.24.0 → 21.26.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mintplayer/ng-bootstrap",
   "private": false,
-  "version": "21.24.0",
+  "version": "21.26.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/MintPlayer/mintplayer-ng-bootstrap",

package/types/mintplayer-ng-bootstrap-dock.d.ts

@@ -84,6 +84,9 @@ declare class MintDockManagerElement extends LitElement {
     static configureDocument(documentRef: Document | null | undefined): void;
     static get observedAttributes(): string[];
     private static instanceCounter;
+    private static readonly TOUCH_LONG_PRESS_MS;
+    private static readonly TOUCH_LONG_PRESS_SLOP_PX;
+    private static readonly TOUCH_PRESS_FEEDBACK_DELAY_MS;
     private documentRef;
     private windowRef;
     private rootEl;
@@ -111,6 +114,7 @@ declare class MintDockManagerElement extends LitElement {
     private cornerSnapXTargets;
     private cornerSnapYTargets;
     private showSnapMarkers;
+    debugLayoutIntegrity: boolean;
     private renderSnapMarkersForCorner;
     private clearSnapMarkers;
     private pendingDragEndTimeout;
@@ -199,13 +203,36 @@ declare class MintDockManagerElement extends LitElement {
     private captureTabDragMetrics;
     private clearPendingTabDragMetrics;
     /**
-     * Pointerdown handler arms a "may become a drag" gesture. Once the pointer
-     * moves past `threshold` pixels we promote it to an actual pane drag via
-     * {@link beginPaneDrag}; if the user releases first we just clear the
-     * pending tab metrics. All listeners self-clean on resolve so the gesture
-     * stays scoped to a single pointerdown.
+     * Pointerdown handler arms a "may become a drag" gesture. Mouse / pen use a
+     * 5 px distance threshold and arm immediately; touch dispatches to
+     * {@link armPaneDragGestureTouch} which requires a 600 ms stationary hold
+     * (so the user can scroll the tabstrip natively without undocking).
+     * Once armed, both paths converge on {@link beginPaneDrag}. All listeners
+     * self-clean on resolve so the gesture stays scoped to a single pointerdown.
      */
     private armPaneDragGesture;
+    /**
+     * Touch-specific gesture arming. With `.dock-tab` set to `touch-action:
+     * none`, the browser never arbitrates the gesture itself, so JS owns it
+     * from frame 1. Three outcomes from the pending state:
+     *
+     *  - User holds within {@link TOUCH_LONG_PRESS_SLOP_PX} for
+     *    {@link TOUCH_LONG_PRESS_MS} → timer fires → drag arms via
+     *    {@link beginPaneDrag}.
+     *  - User moves past slop and the move is mostly horizontal, and the
+     *    strip's `<ul>` is scrollable → enter `scrolling` mode and drive
+     *    `ul.scrollLeft` from JS for the rest of the gesture (no drag, no
+     *    momentum — direct 1:1 finger follow).
+     *  - User moves past slop in any other direction, releases, or
+     *    pointercancel fires → abandoned, no drag, no scroll. Releases
+     *    under slop fire the synthesized click that drives `tab-activate`.
+     *
+     * `touch-action: pan-x` was the original PRD design but doesn't work:
+     * the policy is frozen at touchstart and `setPointerCapture` doesn't
+     * promote it, so first move after a long-press fires pointercancel and
+     * strands the panel. JS-driven scroll is the only model that holds.
+     */
+    private armPaneDragGestureTouch;
     private beginPaneDrag;
     private preparePaneDragSource;
     private endPaneDrag;
@@ -249,8 +276,6 @@ declare class MintDockManagerElement extends LitElement {
     private getNodeAtPath;
     private resolveSplitNode;
     private replaceNodeInTree;
-    private cleanupEmptyStackInTree;
-    private cleanupSplitIfNecessary;
     private dockNodeBeside;
     private forEachStack;
     private findStackContainingPane;
@@ -268,12 +293,42 @@ declare class MintDockManagerElement extends LitElement {
     private removePaneFromLocation;
     private addPaneToLocation;
     private setActivePaneForLocation;
-    private cleanupLocation;
     private reorderPaneInLocation;
     private removeFloatingAt;
     private removePaneFromFloating;
     private normalizeSizesArray;
     private normalizeSplitNode;
+    /**
+     * Bottom-up layout sanitizer. Returns a normalized version of `node` where:
+     * - Empty stacks (panes.length === 0) are dropped (returned as null).
+     * - A stack's `activePane` is repaired if it no longer references one of `panes`.
+     * - Splits whose direction matches a child split are flattened, with sizes
+     *   combined multiplicatively so the resulting on-screen pixel layout is
+     *   identical to the pre-merge one.
+     * - Splits with 0 children become null. Splits with 1 child are unwrapped.
+     *
+     * Idempotent: passing the result back through this method yields the same
+     * structure. Mutates the input tree in place but only returns nodes that
+     * remain part of the layout.
+     */
+    private normalizeLayoutNode;
+    /**
+     * Apply `normalizeLayoutNode` to `rootLayout` and every floating window's
+     * root, drop floating windows whose root collapses to null, and repair
+     * stale `activePane` references on each floating window. Run this at the
+     * end of every public mutation entry point (drop handlers, layout setter,
+     * pane removal) so the tree the renderer sees is always in canonical form.
+     */
+    private normalizeAllLayouts;
+    /**
+     * Dev-mode integrity guard: walks every pane referenced by the current
+     * layout and asserts that the rendered shadow DOM contains a matching
+     * `<slot name="${pane}">`. A missing slot means the layout tree got into
+     * a state the renderer can't display — typically a missed normalize() call
+     * or a render bug. Opt in via the `debug-layout-integrity` attribute or
+     * the `debugLayoutIntegrity` property; off by default.
+     */
+    private verifyProjectionSlots;
     private dispatchLayoutChanged;
     private cloneLayoutNode;
     private cloneFloatingArray;
@@ -281,6 +336,14 @@ declare class MintDockManagerElement extends LitElement {
 
 declare class BsDockManagerComponent implements AfterViewInit {
     readonly layout: _angular_core.InputSignal<DockLayoutNode | DockLayout | null>;
+    /**
+     * Dev-mode integrity guard. When `true`, the inner web component throws
+     * after each render if any registered pane has no projection slot in the
+     * shadow DOM — a signal that the layout tree got corrupted. Off by default;
+     * enable in development to catch layout-logic bugs loudly.
+     */
+    readonly debugLayoutIntegrity: _angular_core.InputSignal<boolean>;
+    protected readonly debugLayoutIntegrityAttr: _angular_core.Signal<"" | null>;
     get layoutSnapshot(): DockLayoutSnapshot | null;
     readonly layoutChange: _angular_core.OutputEmitterRef<DockLayoutSnapshot | null>;
     readonly layoutSnapshotChange: _angular_core.OutputEmitterRef<DockLayoutSnapshot>;
@@ -298,7 +361,7 @@ declare class BsDockManagerComponent implements AfterViewInit {
     private stringifyLayout;
     private cloneLayout;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BsDockManagerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDockManagerComponent, "bs-dock-manager", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; "layoutSnapshotChange": "layoutSnapshotChange"; }, ["panes"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BsDockManagerComponent, "bs-dock-manager", never, { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "debugLayoutIntegrity": { "alias": "debugLayoutIntegrity"; "required": false; "isSignal": true; }; }, { "layoutChange": "layoutChange"; "layoutSnapshotChange": "layoutSnapshotChange"; }, ["panes"], never, true, never>;
 }
 
 export { BsDockManagerComponent, BsDockPaneComponent, MintDockManagerElement };