@scion/workbench 17.0.0-beta.9 → 18.0.0-beta.10

package/esm2022/lib/part/part-bar/part-bar.component.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2023 Swiss Federal Railways
+ * Copyright (c) 2018-2024 Swiss Federal Railways
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -7,43 +7,43 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-import { Component, ElementRef, HostListener, Inject, ViewChild, ViewChildren } from '@angular/core';
+import { Component, computed, effect, ElementRef, HostListener, inject, NgZone, signal, untracked, viewChild, viewChildren } from '@angular/core';
 import { ViewTabComponent } from '../view-tab/view-tab.component';
-import { filter, map, mergeMap, startWith, switchMap, take, takeUntil } from 'rxjs/operators';
-import { animationFrameScheduler, BehaviorSubject, combineLatest, firstValueFrom, from, interval, Subject } from 'rxjs';
-import { ViewDragImageRect } from '../../view-dnd/view-tab-drag-image-renderer.service';
+import { map, mergeMap, takeUntil } from 'rxjs/operators';
+import { from, fromEvent, merge, Observable, Subject, timer } from 'rxjs';
+import { ViewTabDragImageRenderer } from '../../view-dnd/view-tab-drag-image-renderer.service';
+import { ViewDragService } from '../../view-dnd/view-drag.service';
 import { getCssTranslation, setCssClass, setCssVariable, unsetCssClass, unsetCssVariable } from '../../common/dom.util';
-import { filterArray, mapArray, observeInside, subscribeInside } from '@scion/toolkit/operators';
+import { ɵWorkbenchPart } from '../ɵworkbench-part.model';
+import { filterArray, subscribeIn } from '@scion/toolkit/operators';
 import { SciViewportComponent } from '@scion/components/viewport';
-import { SciDimensionModule } from '@scion/components/dimension';
-import { AsyncPipe, NgFor, NgIf } from '@angular/common';
+import { ɵWorkbenchRouter } from '../../routing/ɵworkbench-router.service';
+import { boundingClientRect, dimension } from '@scion/components/dimension';
 import { PartActionBarComponent } from '../part-action-bar/part-action-bar.component';
 import { ViewListButtonComponent } from '../view-list-button/view-list-button.component';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { fromDimension$ } from '@scion/toolkit/observable';
 import { WORKBENCH_ID } from '../../workbench-id';
+import { clamp } from '../../common/math.util';
 import * as i0 from "@angular/core";
-import * as i1 from "../../layout/workbench-layout.service";
-import * as i2 from "../../routing/\u0275workbench-router.service";
-import * as i3 from "../../view-dnd/view-tab-drag-image-renderer.service";
-import * as i4 from "../\u0275workbench-part.model";
-import * as i5 from "../../view-dnd/view-drag.service";
-import * as i6 from "@scion/components/dimension";
 /**
  * Renders view tabs and actions of a {@link WorkbenchPart}.
  *
  * Tabs are added to a viewport, which the user can scroll if not enough space. The viewport grows with its tabs,
  * allowing actions to be placed directly after the last tab or on the right side.
  *
- * ## Drag Events
+ * ## Drag and Drop
+ * This component subscribes to drag events to visualize tabs during a drag operation. The drag operation is initiated in {@link ViewTabComponent}.
+ *
  * We use native drag and drop to support dragging views to other windows.
  *
- * By listening to drag events, the tabbar visualizes tabs during a drag operation. The drag operation is initiated in {@link ViewTabComponent}.
- * - `dragstart` and `dragend` events are fired in the tabbar where the drag operation was initiated.
- * - `dragenter` event is fired when a tab enters the tabbar.
- * - `dragover` events are fired when dragging a tab over the tabbar.
- * - `dragleave` event is fired when a tab leaves the tabbar.
- * - `drop` event is fired when the user drops a tab in the tabbar.
+ * Following events are triggered:
+ * - dragstart: when start dragging a tab (only received in the tabbar where the drag operation has started)
+ * - dragend:   when end dragging a tab, either via drop or cancel (only received in the tabbar where the drag operation has started)
+ * - dragenter: when a tab enters the tabbar
+ * - dragover:  when dragging a tab over the tabbar, every few hundred milliseconds
+ * - dragleave: when a tab leaves the tabbar
+ * - drop:      when the user drops a tab in the tabbar
+ *
  * - Note that `dragleave` event is not fired on drop action. Therefore, always handle both events, `dragleave` and `drop` events, respectively.
  *
  * ## Terminology
@@ -53,34 +53,34 @@ import * as i6 from "@scion/components/dimension";
  *                e.g., to snap the drag image to the tabbar when dragging near it.
  */
 export class PartBarComponent {
-    set injectViewTabs(queryList) {
-        queryList.changes
-            .pipe(startWith(queryList), takeUntilDestroyed(this._destroyRef))
-            .subscribe(queryList => this._viewTabs$.next(queryList.toArray()));
-    }
-    constructor(host, _workbenchId, _workbenchLayoutService, _router, _viewTabDragImageRenderer, _part, _viewDragService, _destroyRef, _zone) {
-        this._workbenchId = _workbenchId;
-        this._workbenchLayoutService = _workbenchLayoutService;
-        this._router = _router;
-        this._viewTabDragImageRenderer = _viewTabDragImageRenderer;
-        this._part = _part;
-        this._viewDragService = _viewDragService;
-        this._destroyRef = _destroyRef;
-        this._zone = _zone;
+    constructor() {
+        this._host = inject((ElementRef)).nativeElement;
         this._viewportChange$ = new Subject();
-        this._viewTabs$ = new BehaviorSubject([]);
-        this._dragenter$ = new Subject();
-        this._dragleave$ = new Subject();
-        this._dragend$ = new Subject();
+        this._workbenchId = inject(WORKBENCH_ID);
+        this._router = inject(ɵWorkbenchRouter);
+        this._viewTabDragImageRenderer = inject(ViewTabDragImageRenderer);
+        this._viewDragService = inject(ViewDragService);
+        this._zone = inject(NgZone);
+        this._viewTabs = viewChildren(ViewTabComponent);
+        this._hostBoundingClientRect = boundingClientRect(inject(ElementRef));
+        this._viewportComponent = viewChild.required(SciViewportComponent);
+        this._viewportComponentElement = viewChild.required(SciViewportComponent, { read: (ElementRef) });
+        this._tabCornerRadiusElement = viewChild.required('tab_corner_radius', { read: (ElementRef) });
+        this._paddingInlineElement = viewChild.required('padding_inline', { read: (ElementRef) });
+        this._fillerElement = viewChild.required('filler');
+        this._viewportBoundingBox = boundingClientRect(this._viewportComponentElement);
+        this.part = inject(ɵWorkbenchPart);
+        this.startActions = computed(() => this.part.actions().filter(action => action.align !== 'end'));
+        this.endActions = computed(() => this.part.actions().filter(action => action.align === 'end'));
         /**
          * Reference to the tab before which to insert the drag source on drop, or `end` if dropping it after the last tab.
          */
-        this.dropTargetViewTab = null;
+        this.dropTargetViewTab = signal(null);
         /**
          * Reference to the tab where the drag operation was started.
          * This reference is only set if the drag operation started on a tab of this tabbar.
          */
-        this.dragSourceViewTab = null;
+        this.dragSourceViewTab = signal(null);
         /**
          * Transfer data of the tab being dragged over this tabbar.
          */
@@ -89,6 +89,10 @@ export class PartBarComponent {
          * Function for snapping the drag image to the tabbar when dragging near it.
          */
         this._constrainFn = null;
+        /**
+         * Signals when unsetting drag state.
+         */
+        this._onUnsetDragState = signal(undefined, { equal: () => false });
         /**
          * Tabbar indents where to display the rounded bottom corners of the first and last view tab.
          */
@@ -96,171 +100,186 @@ export class PartBarComponent {
             left: 0,
             right: 0,
         };
-        /**
-         * Notifies when the drag animation has finished, i.e., tabs have transitioned to their final position.
-         */
-        this._dragAnimationStable$ = interval(0, animationFrameScheduler)
-            .pipe(filter(() => this.isDragAnimationStable()), subscribeInside(continueFn => this._zone.runOutsideAngular(continueFn)), observeInside(continueFn => this._zone.run(continueFn)), map(() => undefined));
-        this._host = host.nativeElement;
-        this.dragover$ = this._viewDragService.tabbarDragOver$.pipe(map(partId => partId === this._part.id));
-    }
-    ngOnInit() {
+        this._maxViewportWidth = this.calculateMaxViewportWidth();
         this.installActiveViewScroller();
         this.installScrolledIntoViewUpdater();
         this.installViewDragListener();
-        this.installTabbarIndentSizeDetector();
-        this.installViewportClientSizeDetector();
+        this.installTabbarIndentSizeTracker();
+        this.installViewportChangeTracker();
     }
     onDoubleClick(event) {
-        if (this._part.isInMainArea) {
+        if (this.part.isInMainArea) {
             this._router.navigate(layout => layout.toggleMaximized()).then();
         }
         event.stopPropagation();
     }
-    get viewIds$() {
-        return this._part.viewIds$;
-    }
-    onTabbarViewportDimensionChange() {
-        this._viewportChange$.next();
-    }
-    onScroll() {
-        this._viewportChange$.next();
-    }
     /**
-     * Method invoked when the user starts dragging a tab of this tabbar.
+     * Method invoked when the user starts dragging a tab of this tabbar, only in the tabbar where the drag started.
      */
-    onViewDragStart(event) {
-        if (!this._viewDragService.isViewDragEvent(event)) {
-            return;
-        }
-        const dragData = this._viewDragService.viewDragData;
-        const dragSourceIndex = this._viewTabs.findIndex(viewTab => viewTab.viewId === dragData.viewId);
-        const dragSourceViewTab = this._viewTabs[dragSourceIndex];
-        const dropTargetViewTab = this._viewTabs[dragSourceIndex + 1] ?? 'end';
-        // Constrain function for snapping the drag image to the tabbar when dragging near it.
+    onTabDragStart() {
+        // Memoize drag data.
+        this._dragData = this._viewDragService.viewDragData();
+        // Indicate dragging over this tabbar.
+        this._viewDragService.signalTabbarDragEnter(this.part.id);
+        // Snap drag image to tabbar when dragging near it.
         this._constrainFn = this.createDragImageConstrainFn();
         this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);
-        this._viewDragService.setTabbarDragover(this._part.id);
-        // When start dragging a view tab, we remove it from the tabbar by setting its `display` to `none` and render its drag image in `ViewTabDragImageRenderer` instead.
-        // However, do not unset the `display` of the drag source during `dragstart`. Otherwise, the native drag operation would be corrupted in Chrome and Edge (but not in Firefox).
-        animationFrameScheduler.schedule(() => {
-            this.dragSourceViewTab = dragSourceViewTab;
-            this.dropTargetViewTab = dropTargetViewTab; // Set drop target to avoid tab animation.
-            setCssVariable(this._host, {
-                '--ɵpart-bar-drag-source-width': `${dragData.viewTabWidth}px`,
-                '--ɵpart-bar-drag-image-placeholder-width': `${dragData.viewTabWidth}px`,
-            });
-        });
-        // When dragging a tab very quickly out of this tabbar, only the `dragstart` event gets fired, but not the `dragenter` event.
-        // Therefore, we subscribe to global `dragenter` events and manually invoke `onTabbarDragLeave` to correctly display the tabs and the active view.
-        this._viewDragService.viewDrag$(window, { eventType: ['dragenter'] })
-            .pipe(take(1), takeUntil(this._dragend$), takeUntilDestroyed(this._destroyRef))
+        // Disable pointer events to not break the drag operation (in Firefox, but not Chrome and Edge).
+        requestAnimationFrame(() => setCssClass(this._host, 'pointer-events-disabled'));
+        // Set CSS class to not animate start dragging.
+        setCssClass(this._host, 'on-drag-start');
+        this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-start'));
+        // Check if the user continues dragging over this tabbar.
+        // If not, the user has quickly dragged the tab out of the tabbar, so manually call `onTabbarDragEnter` and `onTabbarDragLeave`.
+        fromEvent(window, 'dragenter', { once: true })
+            .pipe(takeUntil(merge(fromEvent(this._host, 'dragenter'), fromEvent(this._host, 'dragend'))))
             .subscribe(event => {
-            // Check if the user continues dragging over this tabbar.
-            // If not, the user has quickly dragged the tab out of the tabbar and we  manually call `onTabbarDragLeave`.
-            if ((this._host.compareDocumentPosition(event.target) & Node.DOCUMENT_POSITION_CONTAINED_BY) === 0) {
-                this.onTabbarDragLeave();
-            }
+            this.onTabbarDragEnter(event);
+            this.onTabbarDragLeave(event);
         });
     }
     /**
-     * Method invoked when the user ends dragging a tab of this tabbar.
-     *
-     * Invoked only in the tabbar where the drag operation started, regardless of whether the drag operation was completed or canceled.
+     * Method invoked when the user ends dragging a tab of this tabbar, either by drop or cancel, only in the tabbar where the drag started.
      */
-    onViewDragEnd() {
-        this._dragend$.next();
-        this.unsetDragState();
+    onTabDragEnd(event) {
+        // Unset drag state only on cancel, not on drop, to prevent tabs from temporarily reverting to their pre-drag state. Drag state is reset in `onTabMoved` after a drop.
+        if (event.dataTransfer.dropEffect === 'none') {
+            // Reactivate the drag source view on cancel.
+            this.dragSourceViewTab()?.view().activate({ skipLocationChange: true }).then();
+            // Unset drag state.
+            this.unsetDragState();
+        }
+    }
+    /**
+     * Method invoked when the layout has changed after a drop. The drop may not be related to a tab of this tabbar.
+     */
+    onTabMoved(event) {
+        // Unset drag state only if no new drag has started since the drop.
+        if (this._dragData?.uid === event.dragData?.uid) {
+            this.unsetDragState();
+        }
     }
     /**
      * Method invoked when the user drags a tab into this tabbar.
      */
     onTabbarDragEnter(event) {
-        this._dragenter$.next();
-        this._viewDragService.setTabbarDragover(this._part.id);
-        this._dragData = this._viewDragService.viewDragData;
-        // Constrain function for snapping the drag image to the tabbar when dragging near it.
-        if (!this._constrainFn) {
-            this._constrainFn = this.createDragImageConstrainFn();
-            this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);
+        // Memoize drag data.
+        const dragData = this._dragData = this._viewDragService.viewDragData();
+        // Indicate dragging over this tabbar.
+        this._viewDragService.signalTabbarDragEnter(this.part.id);
+        // Snap drag image to tabbar when dragging near it.
+        this._constrainFn = this.createDragImageConstrainFn();
+        this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);
+        // Set drag source, but only if started the drag operation in this part.
+        // We do not set the drag source in `dragstart` to not break the drag operation (in Chrome and Edge, but not Firefox).
+        if (this._host.classList.contains('on-drag-start')) {
+            this.dragSourceViewTab.set(this._viewTabs().find(viewTab => viewTab.viewId === dragData.viewId) ?? null);
+            setCssVariable(this._host, { '--ɵpart-bar-drag-placeholder-width': `${dragData.viewTabWidth}px` });
         }
-        // Locate drop target to have a nice animation for the drag source placeholder.
-        this.dropTargetViewTab = this.computeDropTarget(event);
-        // Set the CSS class 'drag-enter' to indicate entering the tabbar.
-        setCssClass(this._host, 'drag-enter', 'drag-over');
-        this._dragAnimationStable$
-            .pipe(take(1), takeUntil(this._dragenter$), takeUntilDestroyed(this._destroyRef))
-            .subscribe({ complete: () => unsetCssClass(this._host, 'drag-enter') });
-        setCssVariable(this._host, {
-            '--ɵpart-bar-drag-source-width': `${this._dragData.viewTabWidth}px`,
-            '--ɵpart-bar-drag-image-placeholder-width': `${this._dragData.viewTabWidth}px`,
-        });
+        // Locate the tab the user is dragging over.
+        this.dropTargetViewTab.set(this.computeDropTarget(event));
+        // Disable pointer events on the tabbar for a smoother drag and drop experience when quickly swapping tabs.
+        setCssClass(this._host, 'pointer-events-disabled');
+        // Set CSS class to animate entering the tabbar.
+        setCssClass(this._host, 'on-drag-enter');
+        this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-enter'));
+        // Inject drag source width into CSS.
+        setCssVariable(this._host, { '--ɵpart-bar-drag-source-width': `${dragData.viewTabWidth}px` });
     }
     /**
      * Method invoked when the user drags a tab out of this tabbar.
      */
-    onTabbarDragLeave() {
-        this._dragleave$.next();
-        // Set the CSS class 'drag-leave' to indicate leaving the tabbar.
-        setCssClass(this._host, 'drag-leave');
-        this._dragAnimationStable$
-            .pipe(take(1), takeUntil(this._dragleave$), takeUntilDestroyed(this._destroyRef))
-            .subscribe({ complete: () => unsetCssClass(this._host, 'drag-leave') });
-        this.unsetDragState({ unsetDragSource: false });
-        // Activate the view next to the view being dragged out of this tabbar. But, do not push the navigation into browsing history stack.
-        if (this.dragSourceViewTab && this.dragSourceViewTab.active) {
-            this._router.navigate(layout => layout.activateAdjacentView(this.dragSourceViewTab.viewId), { skipLocationChange: true }).then();
+    onTabbarDragLeave(event) {
+        // Set CSS class to animate leaving the tabbar, but not when canceling the drag operation for instant reset.
+        // Pointer coordinates are not set when the drag operation is canceled or when dragging the tab out of the window.
+        if (event.screenX || event.screenY) {
+            setCssClass(this._host, 'on-drag-leave');
+            this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-leave'));
         }
+        // Activate the adjacent tab, only if the drag operation is not canceled.
+        // The drag event does not provide information about cancelation. Therefore, we wait for a macrotask, canceling it when receiving `dragend`, i.e., the drag operation has been canceled.
+        if (this.dragSourceViewTab()?.active) {
+            timer(0)
+                .pipe(takeUntil(fromEvent(window, 'dragend')))
+                .subscribe(() => this._router.navigate(layout => layout.activateAdjacentView(this.dragSourceViewTab().viewId), { skipLocationChange: true }));
+        }
+        // Clean up drag state.
+        this.unsetDragState({ unsetDragSource: false, unsetDragData: false });
     }
     /**
-     * Method invoked while the user is dragging a tab over this tabbar.
+     * Method invoked when the user is dragging a tab over this tabbar.
      */
-    onTabbarDragOver(event) {
+    onTabbarDragOver(event, dragDistance, scrollDistance) {
+        NgZone.assertNotInAngularZone();
         event.preventDefault(); // allow view drop
-        // Locate the tab over which the user is dragging the tab, but only after pending transitions have ended to prevent tabs from sliding back and forth.
-        if (this.isDragAnimationStable()) {
-            this.dropTargetViewTab = this.computeDropTarget(event);
-            // Synchronize the width of the drag source placeholder with the drag pointer position to move actions along with the pointer.
-            setCssVariable(this._host, { '--ɵpart-bar-drag-image-placeholder-width': `${this.calculateDragImagePlaceholderWidth(event)}px` });
-        }
+        // Locate the tab the user is dragging over.
+        // - Run in animation frame for better performance, most noticeable on lower CPU power.
+        // - Do not wait for the drag animation to complete for a smoother drag and drop experience when quickly moving the tab in the tabbar.
+        requestAnimationFrame(() => {
+            // Skip if the drag operation has ended.
+            if (this._viewDragService.isDragOverTabbar !== this.part.id) {
+                return;
+            }
+            // Ignore the drag distance if `drag-enter` animation is in progress to avoid incorrect drop target computation when dragging a tab from the left.
+            if (this._host.classList.contains('on-drag-enter')) {
+                this.dropTargetViewTab.set(this.computeDropTarget(event, 0));
+            }
+            // Compute drop target only when moving the drag pointer to prevent tabs from sliding back and forth (while animation is in progress)
+            else if (dragDistance) {
+                this.dropTargetViewTab.set(this.computeDropTarget(event, dragDistance));
+            }
+            // Compute drop target when scrolling the viewport, i.e., not moving the drag pointer but scrolling the viewport because placed the drag pointer at the viewport edges.
+            else if (scrollDistance) {
+                this.dropTargetViewTab.set(this.computeDropTarget(event, scrollDistance));
+            }
+            // Set CSS class to animate dragging over the tabbar.
+            setCssClass(this._host, 'drag-over');
+            // Calculate the new size of the drag source placeholder.
+            // The placeholder expands the viewport when dragging a tab to the right, moving part actions along with the dragover event.
+            setCssVariable(this._host, { '--ɵpart-bar-drag-placeholder-width': `${this.calculateDragPlaceholderWidth(event)}px` });
+        });
     }
     /**
      * Method invoked when the user drops a tab in this tabbar.
      */
-    onTabbarDrop() {
+    async onTabbarDrop() {
+        const dragData = this._dragData;
+        const dropTargetViewTab = this.dropTargetViewTab();
+        const dropPosition = dropTargetViewTab === 'end' ? 'end' : this._viewTabs().indexOf(dropTargetViewTab);
         this._viewDragService.dispatchViewMoveEvent({
             source: {
-                workbenchId: this._dragData.workbenchId,
-                partId: this._dragData.partId,
-                viewId: this._dragData.viewId,
-                alternativeViewId: this._dragData.alternativeViewId,
-                viewUrlSegments: this._dragData.viewUrlSegments,
-                navigationHint: this._dragData.navigationHint,
-                classList: this._dragData.classList,
+                workbenchId: dragData.workbenchId,
+                partId: dragData.partId,
+                viewId: dragData.viewId,
+                alternativeViewId: dragData.alternativeViewId,
+                viewUrlSegments: dragData.viewUrlSegments,
+                navigationHint: dragData.navigationHint,
+                navigationData: dragData.navigationData,
+                classList: dragData.classList,
             },
             target: {
                 workbenchId: this._workbenchId,
-                position: this.dropTargetViewTab === 'end' ? 'end' : this._viewTabs.indexOf(this.dropTargetViewTab),
-                elementId: this._part.id,
+                position: dropPosition,
+                elementId: this.part.id,
             },
-        });
-        // Wait undoing the drag state until flushed tab changes to the DOM, i.e., after the layout routing cycle completes.
-        // If we were to undo the drag state immediately during the course of the drop event, the tab layout would temporarily
-        // revert to the state before the drag operation, resulting in an ugly flicker.
-        firstValueFrom(this._workbenchLayoutService.onLayoutChange$).then(() => {
-            this.unsetDragState();
+            dragData: dragData,
         });
     }
     /**
      * Locates the tab before which the dragged tab is to be inserted when it is dropped. Dragging beyond the last tab returns `end`.
      */
-    computeDropTarget(event) {
-        const viewDragImageRect = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData, event);
-        const viewTabs = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab);
+    computeDropTarget(event, dragDistanceX = 0) {
+        const dragImage = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData, event);
+        const viewTabs = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab());
         for (const viewTab of viewTabs) {
-            const viewTabRect = viewTab.host.getBoundingClientRect();
-            const viewTabMiddle = viewTabRect.left + (viewTabRect.width / 2);
-            if (viewDragImageRect.left < viewTabMiddle && (viewTab !== this.dropTargetViewTab || viewDragImageRect.right < viewTabMiddle)) {
+            const { left, width } = viewTab.boundingClientRect();
+            const viewTabHCenter = left + (width / 2);
+            // Moving the pointer to the left.
+            if (dragDistanceX <= 0 && dragImage.left < viewTabHCenter) {
+                return viewTab;
+            }
+            // Moving the pinter to the right.
+            if (dragDistanceX > 0 && dragImage.right < viewTabHCenter) {
                 return viewTab;
             }
         }
@@ -270,49 +289,32 @@ export class PartBarComponent {
      * Creates the function for snapping the drag image to the tabbar when dragging near it.
      */
     createDragImageConstrainFn() {
-        const hostLeft = this._host.getBoundingClientRect().left;
-        const maxViewportWidth = this.calculateMaxViewportWidth();
-        return (rect) => {
-            const viewportBoundingBox = this._viewportElement.nativeElement.getBoundingClientRect();
-            return new ViewDragImageRect({
-                x: Math.min(Math.max(hostLeft + this._tabbarIndent.left, rect.x), hostLeft + maxViewportWidth - rect.width - this._tabbarIndent.right),
-                y: viewportBoundingBox.top,
-                width: rect.width,
-                height: viewportBoundingBox.height, // fit into tabbar, e.g., when dragging a tab into a tabbar of a different height
-            });
-        };
+        return (dragImage) => new DOMRect(clamp(dragImage.x, {
+            min: this._hostBoundingClientRect().left + this._tabbarIndent.left,
+            max: this._hostBoundingClientRect().left + this._maxViewportWidth() - dragImage.width - this._tabbarIndent.right,
+        }), this._viewportBoundingBox().top, dragImage.width, this._viewportBoundingBox().height);
     }
     /**
-     * Calculates the maximum width of the tabbar viewport before an overflow would occur, which can then be used to constrain the drag image.
-     *
-     * To calculate the effective width, we need to simulate an overflow in the DOM. Therefore, call this method only from `dragstart` and not
-     * from `dragover` and disable animations.
+     * Calculates the maximum width of the tabbar viewport before an overflow would occur.
+     * Use to constrain the drag image to the tabbar bounds.
      */
     calculateMaxViewportWidth() {
-        const currentWidth = this._host.style.getPropertyValue('--ɵpart-bar-drag-image-placeholder-width');
-        // Disable animations during calculation and force the viewport to overflow.
-        setCssClass(this._host, 'calculating-max-viewport-width');
-        setCssVariable(this._host, { '--ɵpart-bar-drag-image-placeholder-width': `${this._host.clientWidth}px` });
-        try {
-            return this._viewportElement.nativeElement.getBoundingClientRect().width;
-        }
-        finally {
-            setCssVariable(this._host, { '--ɵpart-bar-drag-image-placeholder-width': currentWidth || null });
-            unsetCssClass(this._host, 'calculating-max-viewport-width');
-        }
+        const fillerDimension = dimension(this._fillerElement);
+        return computed(() => this._viewportBoundingBox().width + fillerDimension().offsetWidth);
     }
     /**
-     * Calculates the width for the drag image placeholder.
+     * Calculates the width for the drag placeholder.
      *
+     * The placeholder expands the viewport when dragging a tab to the right, moving part actions along with the dragover event.
+     *
+     * Calculation:
      * - When dragging over tabs, the width is equal to the width of the drag source.
-     * - When dragging to the right of the last tab, the width of the placeholder is calculated as the distance between the
-     *   last tab and the position of the dragover event. Applying this width will resize the viewport, moving part actions along
-     *   with the dragover event.
+     * - When dragging to the right of the last tab, the width of the placeholder is the distance between the last tab and the position of the drag pointer.
      */
-    calculateDragImagePlaceholderWidth(event) {
+    calculateDragPlaceholderWidth(event) {
         const viewDragImageRect = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData, event);
-        const lastViewTab = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab).at(-1);
-        const lastViewTabRight = lastViewTab?.host.getBoundingClientRect().right ?? this._host.getBoundingClientRect().left + this._tabbarIndent.left;
+        const lastViewTab = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab()).at(-1);
+        const lastViewTabRight = lastViewTab?.boundingClientRect().right ?? this._hostBoundingClientRect().left + this._tabbarIndent.left;
         return Math.max(lastViewTabRight + viewDragImageRect.width, viewDragImageRect.right) - lastViewTabRight;
     }
     /**
@@ -320,11 +322,12 @@ export class PartBarComponent {
      * The animation is considered stable when all tabs have moved to their final position.
      */
     isDragAnimationStable() {
-        if (!this.dropTargetViewTab) {
-            return this._viewTabs.every(viewTab => getCssTranslation(viewTab.host).translateX === 'none');
+        const dropTargetViewTab = this.dropTargetViewTab();
+        if (this._viewDragService.isDragOverTabbar !== this.part.id) {
+            return this._viewTabs().every(viewTab => getCssTranslation(viewTab.host).translateX === 'none');
         }
-        const viewTabs = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab);
-        const dropTargetIndex = this.dropTargetViewTab === 'end' ? viewTabs.length : viewTabs.indexOf(this.dropTargetViewTab);
+        const viewTabs = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab());
+        const dropTargetIndex = dropTargetViewTab === 'end' ? viewTabs.length : viewTabs.indexOf(dropTargetViewTab);
         const dragSourceWidth = this._dragData.viewTabWidth;
         return viewTabs.every((viewTab, i) => {
             const viewTabTranslateX = getCssTranslation(viewTab.host).translateX;
@@ -339,33 +342,63 @@ export class PartBarComponent {
             return true;
         });
     }
+    /**
+     * Cleans up the drag state, unsetting drag data and drag source based on provided options.
+     */
     unsetDragState(options) {
-        if (options?.unsetDragSource ?? true) {
-            this.dragSourceViewTab = null;
-        }
-        this.dropTargetViewTab = null;
-        this._dragData = null;
+        this.dropTargetViewTab.set(null);
+        this._onUnsetDragState.set();
         this._viewTabDragImageRenderer.unsetConstrainDragImageRectFn(this._constrainFn);
+        this._viewDragService.signalTabbarDragLeave(this.part.id);
         this._constrainFn = null;
-        unsetCssClass(this._host, 'drag-over');
-        unsetCssVariable(this._host, '--ɵpart-bar-drag-source-width', '--ɵpart-bar-drag-image-placeholder-width');
-        this._viewDragService.unsetTabbarDragover(this._part.id);
+        unsetCssClass(this._host, 'drag-over', 'pointer-events-disabled');
+        unsetCssVariable(this._host, '--ɵpart-bar-drag-source-width', '--ɵpart-bar-drag-placeholder-width');
+        if (options?.unsetDragSource ?? true) {
+            this.dragSourceViewTab.set(null);
+        }
+        if (options?.unsetDragData ?? true) {
+            this._dragData = null;
+        }
     }
-    get _viewTabs() {
-        return this._viewTabs$.value;
+    /**
+     * Executes given function when the drag animation has finished, i.e., tabs have transitioned to their final position.
+     */
+    onDragAnimationStable(callback) {
+        if (NgZone.isInAngularZone()) {
+            this._zone.runOutsideAngular(() => this.onDragAnimationStable(callback));
+            return;
+        }
+        requestAnimationFrame(() => this.isDragAnimationStable() ? callback() : this.onDragAnimationStable(callback));
     }
     /**
      * Scrolls the tab of the active view into view.
      */
     installActiveViewScroller() {
-        this._viewTabs$
-            .pipe(switchMap(viewTabs => combineLatest(viewTabs.map(viewTab => viewTab.view.active$))), takeUntilDestroyed(this._destroyRef))
-            .subscribe(() => {
-            // There may be no active view in the tabbar, e.g., when dragging the last view out of the tabbar.
-            const activeViewTab = this._viewTabs.find(viewTab => viewTab.active);
-            if (activeViewTab && !this._viewportComponent.isElementInView(activeViewTab.host, 'full')) {
-                this._viewportComponent.scrollIntoView(activeViewTab.host);
+        effect(() => {
+            // Track the active view.
+            const activeViewId = this.part.activeViewId();
+            // There may be no active view, e.g., if no view has been activated, or when dragging the last view out of the tabbar.
+            if (!activeViewId) {
+                return;
             }
+            // Do not track rendered tabs in general to prevent unwanted scrolling when opening or closing inactive tabs.
+            const viewTabs = untracked(() => this._viewTabs());
+            // Get a reference to the currently rendered active tab, waiting if necessary by tracking the rendered tabs.
+            const activeViewTab = viewTabs.find(viewTab => viewTab.viewId === activeViewId);
+            if (!activeViewTab) {
+                this._viewTabs(); // Track rendered tabs to re-execute once rendered.
+                return;
+            }
+            // Track navigation of the active view, scrolling its tab into view if necessary.
+            activeViewTab.view().navigationId();
+            // Track unsetting drag state to ensure the active view is scrolled into view after drop or cancel.
+            this._onUnsetDragState();
+            // Scroll the tab into view if scrolled out of view.
+            untracked(() => requestAnimationFrame(() => {
+                if (!this._viewportComponent().isElementInView(activeViewTab.host, 'full')) {
+                    this._viewportComponent().scrollIntoView(activeViewTab.host);
+                }
+            }));
         });
     }
     /**
@@ -373,87 +406,123 @@ export class PartBarComponent {
      */
     installScrolledIntoViewUpdater() {
         this._viewportChange$
-            .pipe(map(() => this._viewTabs), filterArray(viewTab => viewTab !== this.dragSourceViewTab), // skip drag source as always scrolled out of view
-        mergeMap(viewTabs => from(viewTabs)), takeUntilDestroyed(this._destroyRef))
+            .pipe(map(() => this._viewTabs()), filterArray(viewTab => viewTab !== this.dragSourceViewTab()), // skip drag source as always scrolled out of view
+        mergeMap(viewTabs => from(viewTabs)), takeUntilDestroyed())
             .subscribe(viewTab => {
-            viewTab.view.scrolledIntoView = this._viewportComponent.isElementInView(viewTab.host, 'full');
+            viewTab.view().scrolledIntoView = this._viewportComponent().isElementInView(viewTab.host, 'full');
         });
     }
+    /**
+     * Subscribes to drag events.
+     */
     installViewDragListener() {
+        const zone = inject(NgZone);
+        // Subscribe to drag events relevant for this tabbar.
         this._viewDragService.viewDrag$(this._host)
-            .pipe(takeUntilDestroyed(this._destroyRef))
-            .subscribe((event) => {
+            .pipe(subscribeIn(fn => zone.runOutsideAngular(fn)), calculateDistance(() => this._viewportComponent()), // provide viewport lazily because not injected yet
+        takeUntilDestroyed())
+            .subscribe(({ event, dragDistance, scrollDistance }) => {
             switch (event.type) {
+                case 'dragstart':
+                    this.onTabDragStart();
+                    break;
+                case 'dragend':
+                    this.onTabDragEnd(event);
+                    break;
                 case 'dragenter':
                     this.onTabbarDragEnter(event);
                     break;
                 case 'dragover':
-                    this.onTabbarDragOver(event);
+                    this.onTabbarDragOver(event, dragDistance, scrollDistance);
                     break;
                 case 'dragleave':
-                    this.onTabbarDragLeave();
+                    this.onTabbarDragLeave(event);
                     break;
                 case 'drop':
-                    this.onTabbarDrop();
+                    this.onTabbarDrop().then();
                     break;
             }
         });
+        // Get notified when a view has moved in the layout.
+        this._viewDragService.viewMoved$
+            .pipe(subscribeIn(fn => zone.runOutsideAngular(fn)), takeUntilDestroyed())
+            .subscribe(event => this.onTabMoved(event));
+        /**
+         * Calculates the distance the drag pointer and viewport have moved since the last drag event.
+         */
+        function calculateDistance(viewport) {
+            return source$ => new Observable(observer => {
+                let lastScreenX;
+                let lastScrollLeft;
+                const subscription = source$.subscribe(event => {
+                    observer.next({
+                        event,
+                        dragDistance: event.screenX - (lastScreenX ?? event.screenX),
+                        scrollDistance: viewport().scrollLeft - (lastScrollLeft ?? viewport().scrollLeft),
+                    });
+                    lastScreenX = event.screenX;
+                    lastScrollLeft = viewport().scrollLeft;
+                });
+                return () => subscription.unsubscribe();
+            });
+        }
     }
-    installViewportClientSizeDetector() {
-        fromDimension$(this._viewportComponent.viewportClientElement)
-            .pipe(subscribeInside(fn => this._zone.run(fn)), takeUntilDestroyed(this._destroyRef))
-            .subscribe(() => this._viewportChange$.next());
+    /**
+     * Emits on {@link _viewportChange$} when the viewport size or scroll position changes.
+     */
+    installViewportChangeTracker() {
+        const viewportSize = dimension(computed(() => this._viewportComponentElement().nativeElement));
+        const viewportClientSize = dimension(computed(() => this._viewportComponent().viewportClientElement));
+        const zone = inject(NgZone);
+        // Detect resizing.
+        effect(() => {
+            // Track viewport and viewport client sizes.
+            viewportSize();
+            viewportClientSize();
+            untracked(() => this._viewportChange$.next());
+        });
+        // Detect scrolling.
+        effect(onCleanup => {
+            const viewport = this._viewportComponent().viewportElement;
+            untracked(() => {
+                const subscription = fromEvent(viewport, 'scroll')
+                    .pipe(subscribeIn(fn => zone.runOutsideAngular(fn)))
+                    .subscribe(() => this._viewportChange$.next());
+                onCleanup(() => subscription.unsubscribe());
+            });
+        });
     }
-    installTabbarIndentSizeDetector() {
-        combineLatest([fromDimension$(this._tabCornerRadiusElement.nativeElement), fromDimension$(this._paddingInlineElement.nativeElement)])
-            .pipe(subscribeInside(fn => this._zone.runOutsideAngular(fn)), mapArray(dimension => dimension.clientWidth), takeUntilDestroyed(this._destroyRef))
-            .subscribe(([tabCornerRadius, paddingInline]) => {
-            this._tabbarIndent = { left: tabCornerRadius + paddingInline, right: tabCornerRadius + paddingInline };
-            setCssVariable(this._host, { '--ɵpart-bar-indent-left': `${this._tabbarIndent.left}px` });
-            setCssVariable(this._host, { '--ɵpart-bar-indent-right': `${this._tabbarIndent.right}px` });
+    /**
+     * Tracks the tabbar indents.
+     */
+    installTabbarIndentSizeTracker() {
+        const tabCornerRadiusDimension = dimension(this._tabCornerRadiusElement);
+        const paddingInlineDimension = dimension(this._paddingInlineElement);
+        effect(() => {
+            const indent = tabCornerRadiusDimension().clientWidth + paddingInlineDimension().clientWidth;
+            this._tabbarIndent = { left: indent, right: indent };
+            setCssVariable(this._host, {
+                '--ɵpart-bar-indent-left': `${this._tabbarIndent.left}px`,
+                '--ɵpart-bar-indent-right': `${this._tabbarIndent.right}px`,
+            });
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: PartBarComponent, deps: [{ token: i0.ElementRef }, { token: WORKBENCH_ID }, { token: i1.WorkbenchLayoutService }, { token: i2.ɵWorkbenchRouter }, { token: i3.ViewTabDragImageRenderer }, { token: i4.ɵWorkbenchPart }, { token: i5.ViewDragService }, { token: i0.DestroyRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.6", type: PartBarComponent, isStandalone: true, selector: "wb-part-bar", host: { listeners: { "dblclick": "onDoubleClick($event)", "dragstart": "onViewDragStart($event)", "dragend": "onViewDragEnd()" } }, viewQueries: [{ propertyName: "_viewportElement", first: true, predicate: SciViewportComponent, descendants: true, read: ElementRef, static: true }, { propertyName: "_viewportComponent", first: true, predicate: SciViewportComponent, descendants: true, static: true }, { propertyName: "_tabCornerRadiusElement", first: true, predicate: ["tab_corner_radius"], descendants: true, static: true }, { propertyName: "_paddingInlineElement", first: true, predicate: ["padding_inline"], descendants: true, static: true }, { propertyName: "injectViewTabs", predicate: ViewTabComponent, descendants: true }], ngImport: i0, template: "<sci-viewport class=\"tabbar\" scrollbarStyle=\"hidden\"\n              [class.dragover]=\"dragover$ | async\"\n              sciDimension (sciDimensionChange)=\"onTabbarViewportDimensionChange()\"\n              (scroll)=\"onScroll()\">\n  <ng-container *ngFor=\"let viewId of viewIds$ | async;\">\n    <div class=\"divider\" *ngIf=\"viewtab === dropTargetViewTab\"></div>\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab\">\n    </wb-view-tab>\n    <div class=\"divider\"></div>\n  </ng-container>\n\n  <!-- Placeholder element to grow the viewport to fit the drag image. -->\n  <div class=\"drag-image-placeholder\"></div>\n</sci-viewport>\n<wb-part-action-bar/>\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n", styles: ["@charset \"UTF-8\";:host{--\\275part-bar-indent-left: 0;--\\275part-bar-indent-right: 0;--\\275part-bar-drag-source-width: 0;--\\275part-bar-drag-image-placeholder-width: 0;display:flex;color:var(--sci-workbench-tab-text-color);background-color:var(--sci-workbench-part-bar-background-color);border-top:var(--sci-workbench-part-bar-padding-top) solid transparent;background-clip:border-box;height:var(--sci-workbench-tab-height);box-sizing:content-box;position:relative;container-name:viewtab;container-type:size}wb-workbench:has(wb-main-area-layout) wb-part:not(.main-area) :host{background-color:var(--sci-workbench-part-peripheral-bar-background-color)}:host>sci-viewport.tabbar{flex:initial}:host>sci-viewport.tabbar::part(content){display:flex;padding-left:var(--\\275part-bar-indent-left);padding-right:var(--\\275part-bar-indent-right)}:host>sci-viewport.tabbar:not(.dragover):not(:has(wb-view-tab:not(.drag-source)))::part(content){padding-right:0}:host>sci-viewport.tabbar>wb-view-tab{flex:none}:host>sci-viewport.tabbar>wb-view-tab.drag-source{display:none}:host>sci-viewport.tabbar>div.divider{flex:none;display:flex;position:relative;width:0}:host>sci-viewport.tabbar>div.divider:after{flex:none;align-self:center;content:\"\";position:absolute;width:1px;left:-1px;height:65%;background-color:var(--sci-workbench-part-bar-divider-color)}:host>sci-viewport.tabbar>div.drag-image-placeholder{flex:none;width:var(--\\275part-bar-drag-image-placeholder-width)}:host>sci-viewport.tabbar>wb-view-tab.drop-target,:host>sci-viewport.tabbar wb-view-tab.drop-target~:is(wb-view-tab,div.divider),:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drop-target){transform:translate(var(--\\275part-bar-drag-source-width))}:host>sci-viewport.tabbar>wb-view-tab:is(.active,.drag-source)+div.divider{display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.active:not(.drag-source)){display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drag-source:not(.active)){display:none}:host>wb-part-action-bar{flex:auto}:host>wb-view-list-button{flex:none}:host:before{content:\"\";position:absolute;bottom:0;left:0;right:0;height:1px;background-color:var(--sci-workbench-tab-border-color)}:host>div.tab-corner-radius{position:absolute;visibility:hidden;width:var(--sci-workbench-tab-border-radius)}:host>div.padding-inline{position:absolute;visibility:hidden;width:var(--sci-workbench-part-bar-padding-inline)}:host:not(.calculating-max-viewport-width).drag-enter wb-view-tab,:host:not(.calculating-max-viewport-width).drag-enter div.divider,:host:not(.calculating-max-viewport-width).drag-over wb-view-tab,:host:not(.calculating-max-viewport-width).drag-over div.divider,:host:not(.calculating-max-viewport-width).drag-leave wb-view-tab,:host:not(.calculating-max-viewport-width).drag-leave div.divider{transition:transform 175ms cubic-bezier(0,0,.2,1)}:host:not(.calculating-max-viewport-width).drag-enter div.drag-image-placeholder,:host:not(.calculating-max-viewport-width).drag-leave div.drag-image-placeholder{transition:width 175ms cubic-bezier(0,0,.2,1)}\n"], dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "component", type: SciViewportComponent, selector: "sci-viewport", inputs: ["scrollbarStyle"], outputs: ["scroll"] }, { kind: "ngmodule", type: SciDimensionModule }, { kind: "directive", type: i6.SciDimensionDirective, selector: "[sciDimension]", inputs: ["emitOutsideAngular"], outputs: ["sciDimensionChange"], exportAs: ["sciDimension"] }, { kind: "component", type: ViewTabComponent, selector: "wb-view-tab", inputs: ["viewId"] }, { kind: "component", type: PartActionBarComponent, selector: "wb-part-action-bar" }, { kind: "component", type: ViewListButtonComponent, selector: "wb-view-list-button" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+    ngOnDestroy() {
+        this.unsetDragState();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: PartBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.2", type: PartBarComponent, isStandalone: true, selector: "wb-part-bar", host: { listeners: { "dblclick": "onDoubleClick($event)" } }, viewQueries: [{ propertyName: "_viewTabs", predicate: ViewTabComponent, descendants: true, isSignal: true }, { propertyName: "_viewportComponent", first: true, predicate: SciViewportComponent, descendants: true, isSignal: true }, { propertyName: "_viewportComponentElement", first: true, predicate: SciViewportComponent, descendants: true, read: ElementRef, isSignal: true }, { propertyName: "_tabCornerRadiusElement", first: true, predicate: ["tab_corner_radius"], descendants: true, read: ElementRef, isSignal: true }, { propertyName: "_paddingInlineElement", first: true, predicate: ["padding_inline"], descendants: true, read: ElementRef, isSignal: true }, { propertyName: "_fillerElement", first: true, predicate: ["filler"], descendants: true, isSignal: true }], ngImport: i0, template: "<sci-viewport class=\"tabbar e2e-tabbar\" scrollbarStyle=\"hidden\">\n  @for (viewId of part.viewIds(); track viewId) {\n    @if (viewtab === dropTargetViewTab()) {\n      <div class=\"divider\"></div>\n    }\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab()\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab()\"/>\n    <div class=\"divider\"></div>\n  }\n\n  <!-- Placeholder for expanding the viewport when dragging a tab to the right, moving part actions along with the dragover event. -->\n  <div class=\"drag-placeholder\"></div>\n</sci-viewport>\n\n<!-- Actions -->\n@if (startActions().length) {\n  <wb-part-action-bar [actions]=\"startActions()\" class=\"start\"/>\n}\n<div class=\"filler\" #filler></div>\n@if (endActions().length) {\n  <wb-part-action-bar [actions]=\"endActions()\" class=\"end\"/>\n}\n\n<!-- View List Dropdown -->\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n", styles: ["@charset \"UTF-8\";:host{--\\275part-bar-indent-left: 0;--\\275part-bar-indent-right: 0;--\\275part-bar-drag-source-width: 0;--\\275part-bar-drag-placeholder-width: 0;display:flex;color:var(--sci-workbench-tab-text-color);background-color:var(--sci-workbench-part-bar-background-color);border-top:var(--sci-workbench-part-bar-padding-top) solid transparent;background-clip:border-box;height:var(--sci-workbench-tab-height);box-sizing:content-box;position:relative;container-name:viewtab;container-type:size}wb-workbench:has(wb-main-area-layout) wb-part:not(.main-area) :host{background-color:var(--sci-workbench-part-peripheral-bar-background-color)}:host>sci-viewport.tabbar{flex:initial}:host>sci-viewport.tabbar::part(content){display:flex;padding-left:var(--\\275part-bar-indent-left);padding-right:var(--\\275part-bar-indent-right)}:host>sci-viewport.tabbar>wb-view-tab{flex:none}:host>sci-viewport.tabbar>wb-view-tab.drag-source{display:none}:host>sci-viewport.tabbar>div.divider{flex:none;display:flex;position:relative;width:0}:host>sci-viewport.tabbar>div.divider:after{flex:none;align-self:center;content:\"\";position:absolute;width:1px;left:-1px;height:65%;background-color:var(--sci-workbench-part-bar-divider-color)}:host>sci-viewport.tabbar>div.drag-placeholder{flex:none;width:var(--\\275part-bar-drag-placeholder-width)}:host>sci-viewport.tabbar>wb-view-tab.drop-target,:host>sci-viewport.tabbar wb-view-tab.drop-target~:is(wb-view-tab,div.divider),:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drop-target){transform:translate(var(--\\275part-bar-drag-source-width))}:host>sci-viewport.tabbar>wb-view-tab:is(.active,.drag-source)+div.divider{display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.active:not(.drag-source)){display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drag-source:not(.active)){display:none}:host:not(.drag-over)>sci-viewport.tabbar:not(:has(wb-view-tab:not(.drag-source)))::part(content){padding-right:0}:host>wb-part-action-bar.start{flex:none;padding-left:var(--sci-workbench-part-bar-actions-padding-inline)}:host>div.filler{flex:auto}:host>wb-part-action-bar.end{flex:none;padding-right:var(--sci-workbench-part-bar-actions-padding-inline)}:host>wb-view-list-button{flex:none}:host:before{content:\"\";position:absolute;bottom:0;left:0;right:0;height:1px;background-color:var(--sci-workbench-tab-border-color)}:host>div.tab-corner-radius{position:absolute;visibility:hidden;width:var(--sci-workbench-tab-border-radius)}:host>div.padding-inline{position:absolute;visibility:hidden;width:var(--sci-workbench-part-bar-padding-inline)}:host.on-drag-enter:not(.on-drag-start) wb-view-tab,:host.on-drag-enter:not(.on-drag-start) div.divider,:host.drag-over wb-view-tab,:host.drag-over div.divider,:host.on-drag-leave wb-view-tab,:host.on-drag-leave div.divider{transition:transform 175ms cubic-bezier(0,0,.2,1)}:host.on-drag-enter:not(.on-drag-start) div.drag-placeholder,:host.on-drag-leave div.drag-placeholder{transition:width 175ms cubic-bezier(0,0,.2,1)}:host:not(:has(wb-view-tab.drag-source)):not(:has(wb-view-tab.drop-target)):not(.drag-over) div.drag-placeholder{display:none}:host.pointer-events-disabled>sci-viewport.tabbar::part(content){pointer-events:none}\n"], dependencies: [{ kind: "component", type: SciViewportComponent, selector: "sci-viewport", inputs: ["scrollbarStyle"], outputs: ["scroll"] }, { kind: "component", type: ViewTabComponent, selector: "wb-view-tab", inputs: ["viewId"] }, { kind: "component", type: PartActionBarComponent, selector: "wb-part-action-bar", inputs: ["actions"] }, { kind: "component", type: ViewListButtonComponent, selector: "wb-view-list-button" }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: PartBarComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: PartBarComponent, decorators: [{
             type: Component,
             args: [{ selector: 'wb-part-bar', standalone: true, imports: [
-                        NgFor,
-                        AsyncPipe,
                         SciViewportComponent,
-                        SciDimensionModule,
                         ViewTabComponent,
                         PartActionBarComponent,
                         ViewListButtonComponent,
-                        NgIf,
-                    ], template: "<sci-viewport class=\"tabbar\" scrollbarStyle=\"hidden\"\n              [class.dragover]=\"dragover$ | async\"\n              sciDimension (sciDimensionChange)=\"onTabbarViewportDimensionChange()\"\n              (scroll)=\"onScroll()\">\n  <ng-container *ngFor=\"let viewId of viewIds$ | async;\">\n    <div class=\"divider\" *ngIf=\"viewtab === dropTargetViewTab\"></div>\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab\">\n    </wb-view-tab>\n    <div class=\"divider\"></div>\n  </ng-container>\n\n  <!-- Placeholder element to grow the viewport to fit the drag image. -->\n  <div class=\"drag-image-placeholder\"></div>\n</sci-viewport>\n<wb-part-action-bar/>\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n", styles: ["@charset \"UTF-8\";:host{--\\275part-bar-indent-left: 0;--\\275part-bar-indent-right: 0;--\\275part-bar-drag-source-width: 0;--\\275part-bar-drag-image-placeholder-width: 0;display:flex;color:var(--sci-workbench-tab-text-color);background-color:var(--sci-workbench-part-bar-background-color);border-top:var(--sci-workbench-part-bar-padding-top) solid transparent;background-clip:border-box;height:var(--sci-workbench-tab-height);box-sizing:content-box;position:relative;container-name:viewtab;container-type:size}wb-workbench:has(wb-main-area-layout) wb-part:not(.main-area) :host{background-color:var(--sci-workbench-part-peripheral-bar-background-color)}:host>sci-viewport.tabbar{flex:initial}:host>sci-viewport.tabbar::part(content){display:flex;padding-left:var(--\\275part-bar-indent-left);padding-right:var(--\\275part-bar-indent-right)}:host>sci-viewport.tabbar:not(.dragover):not(:has(wb-view-tab:not(.drag-source)))::part(content){padding-right:0}:host>sci-viewport.tabbar>wb-view-tab{flex:none}:host>sci-viewport.tabbar>wb-view-tab.drag-source{display:none}:host>sci-viewport.tabbar>div.divider{flex:none;display:flex;position:relative;width:0}:host>sci-viewport.tabbar>div.divider:after{flex:none;align-self:center;content:\"\";position:absolute;width:1px;left:-1px;height:65%;background-color:var(--sci-workbench-part-bar-divider-color)}:host>sci-viewport.tabbar>div.drag-image-placeholder{flex:none;width:var(--\\275part-bar-drag-image-placeholder-width)}:host>sci-viewport.tabbar>wb-view-tab.drop-target,:host>sci-viewport.tabbar wb-view-tab.drop-target~:is(wb-view-tab,div.divider),:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drop-target){transform:translate(var(--\\275part-bar-drag-source-width))}:host>sci-viewport.tabbar>wb-view-tab:is(.active,.drag-source)+div.divider{display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.active:not(.drag-source)){display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drag-source:not(.active)){display:none}:host>wb-part-action-bar{flex:auto}:host>wb-view-list-button{flex:none}:host:before{content:\"\";position:absolute;bottom:0;left:0;right:0;height:1px;background-color:var(--sci-workbench-tab-border-color)}:host>div.tab-corner-radius{position:absolute;visibility:hidden;width:var(--sci-workbench-tab-border-radius)}:host>div.padding-inline{position:absolute;visibility:hidden;width:var(--sci-workbench-part-bar-padding-inline)}:host:not(.calculating-max-viewport-width).drag-enter wb-view-tab,:host:not(.calculating-max-viewport-width).drag-enter div.divider,:host:not(.calculating-max-viewport-width).drag-over wb-view-tab,:host:not(.calculating-max-viewport-width).drag-over div.divider,:host:not(.calculating-max-viewport-width).drag-leave wb-view-tab,:host:not(.calculating-max-viewport-width).drag-leave div.divider{transition:transform 175ms cubic-bezier(0,0,.2,1)}:host:not(.calculating-max-viewport-width).drag-enter div.drag-image-placeholder,:host:not(.calculating-max-viewport-width).drag-leave div.drag-image-placeholder{transition:width 175ms cubic-bezier(0,0,.2,1)}\n"] }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [WORKBENCH_ID]
-                }] }, { type: i1.WorkbenchLayoutService }, { type: i2.ɵWorkbenchRouter }, { type: i3.ViewTabDragImageRenderer }, { type: i4.ɵWorkbenchPart }, { type: i5.ViewDragService }, { type: i0.DestroyRef }, { type: i0.NgZone }], propDecorators: { _viewportElement: [{
-                type: ViewChild,
-                args: [SciViewportComponent, { static: true, read: ElementRef }]
-            }], _viewportComponent: [{
-                type: ViewChild,
-                args: [SciViewportComponent, { static: true }]
-            }], _tabCornerRadiusElement: [{
-                type: ViewChild,
-                args: ['tab_corner_radius', { static: true }]
-            }], _paddingInlineElement: [{
-                type: ViewChild,
-                args: ['padding_inline', { static: true }]
-            }], injectViewTabs: [{
-                type: ViewChildren,
-                args: [ViewTabComponent]
-            }], onDoubleClick: [{
+                    ], template: "<sci-viewport class=\"tabbar e2e-tabbar\" scrollbarStyle=\"hidden\">\n  @for (viewId of part.viewIds(); track viewId) {\n    @if (viewtab === dropTargetViewTab()) {\n      <div class=\"divider\"></div>\n    }\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab()\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab()\"/>\n    <div class=\"divider\"></div>\n  }\n\n  <!-- Placeholder for expanding the viewport when dragging a tab to the right, moving part actions along with the dragover event. -->\n  <div class=\"drag-placeholder\"></div>\n</sci-viewport>\n\n<!-- Actions -->\n@if (startActions().length) {\n  <wb-part-action-bar [actions]=\"startActions()\" class=\"start\"/>\n}\n<div class=\"filler\" #filler></div>\n@if (endActions().length) {\n  <wb-part-action-bar [actions]=\"endActions()\" class=\"end\"/>\n}\n\n<!-- View List Dropdown -->\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n", styles: ["@charset \"UTF-8\";:host{--\\275part-bar-indent-left: 0;--\\275part-bar-indent-right: 0;--\\275part-bar-drag-source-width: 0;--\\275part-bar-drag-placeholder-width: 0;display:flex;color:var(--sci-workbench-tab-text-color);background-color:var(--sci-workbench-part-bar-background-color);border-top:var(--sci-workbench-part-bar-padding-top) solid transparent;background-clip:border-box;height:var(--sci-workbench-tab-height);box-sizing:content-box;position:relative;container-name:viewtab;container-type:size}wb-workbench:has(wb-main-area-layout) wb-part:not(.main-area) :host{background-color:var(--sci-workbench-part-peripheral-bar-background-color)}:host>sci-viewport.tabbar{flex:initial}:host>sci-viewport.tabbar::part(content){display:flex;padding-left:var(--\\275part-bar-indent-left);padding-right:var(--\\275part-bar-indent-right)}:host>sci-viewport.tabbar>wb-view-tab{flex:none}:host>sci-viewport.tabbar>wb-view-tab.drag-source{display:none}:host>sci-viewport.tabbar>div.divider{flex:none;display:flex;position:relative;width:0}:host>sci-viewport.tabbar>div.divider:after{flex:none;align-self:center;content:\"\";position:absolute;width:1px;left:-1px;height:65%;background-color:var(--sci-workbench-part-bar-divider-color)}:host>sci-viewport.tabbar>div.drag-placeholder{flex:none;width:var(--\\275part-bar-drag-placeholder-width)}:host>sci-viewport.tabbar>wb-view-tab.drop-target,:host>sci-viewport.tabbar wb-view-tab.drop-target~:is(wb-view-tab,div.divider),:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drop-target){transform:translate(var(--\\275part-bar-drag-source-width))}:host>sci-viewport.tabbar>wb-view-tab:is(.active,.drag-source)+div.divider{display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.active:not(.drag-source)){display:none}:host>sci-viewport.tabbar>div.divider:has(+wb-view-tab.drag-source:not(.active)){display:none}:host:not(.drag-over)>sci-viewport.tabbar:not(:has(wb-view-tab:not(.drag-source)))::part(content){padding-right:0}:host>wb-part-action-bar.start{flex:none;padding-left:var(--sci-workbench-part-bar-actions-padding-inline)}:host>div.filler{flex:auto}:host>wb-part-action-bar.end{flex:none;padding-right:var(--sci-workbench-part-bar-actions-padding-inline)}:host>wb-view-list-button{flex:none}:host:before{content:\"\";position:absolute;bottom:0;left:0;right:0;height:1px;background-color:var(--sci-workbench-tab-border-color)}:host>div.tab-corner-radius{position:absolute;visibility:hidden;width:var(--sci-workbench-tab-border-radius)}:host>div.padding-inline{position:absolute;visibility:hidden;width:var(--sci-workbench-part-bar-padding-inline)}:host.on-drag-enter:not(.on-drag-start) wb-view-tab,:host.on-drag-enter:not(.on-drag-start) div.divider,:host.drag-over wb-view-tab,:host.drag-over div.divider,:host.on-drag-leave wb-view-tab,:host.on-drag-leave div.divider{transition:transform 175ms cubic-bezier(0,0,.2,1)}:host.on-drag-enter:not(.on-drag-start) div.drag-placeholder,:host.on-drag-leave div.drag-placeholder{transition:width 175ms cubic-bezier(0,0,.2,1)}:host:not(:has(wb-view-tab.drag-source)):not(:has(wb-view-tab.drop-target)):not(.drag-over) div.drag-placeholder{display:none}:host.pointer-events-disabled>sci-viewport.tabbar::part(content){pointer-events:none}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { onDoubleClick: [{
                 type: HostListener,
                 args: ['dblclick', ['$event']]
-            }], onViewDragStart: [{
-                type: HostListener,
-                args: ['dragstart', ['$event']]
-            }], onViewDragEnd: [{
-                type: HostListener,
-                args: ['dragend']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"part-bar.component.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/part/part-bar/part-bar.component.ts","../../../../../../../projects/scion/workbench/src/lib/part/part-bar/part-bar.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2023 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Component, DestroyRef, ElementRef, HostListener, Inject, NgZone, OnInit, QueryList, ViewChild, ViewChildren} from '@angular/core';\nimport {ViewTabComponent} from '../view-tab/view-tab.component';\nimport {WorkbenchLayoutService} from '../../layout/workbench-layout.service';\nimport {filter, map, mergeMap, startWith, switchMap, take, takeUntil} from 'rxjs/operators';\nimport {animationFrameScheduler, BehaviorSubject, combineLatest, firstValueFrom, from, interval, Observable, Subject} from 'rxjs';\nimport {ConstrainFn, ViewDragImageRect, ViewTabDragImageRenderer} from '../../view-dnd/view-tab-drag-image-renderer.service';\nimport {ViewDragData, ViewDragService} from '../../view-dnd/view-drag.service';\nimport {getCssTranslation, setCssClass, setCssVariable, unsetCssClass, unsetCssVariable} from '../../common/dom.util';\nimport {ɵWorkbenchPart} from '../ɵworkbench-part.model';\nimport {filterArray, mapArray, observeInside, subscribeInside} from '@scion/toolkit/operators';\nimport {SciViewportComponent} from '@scion/components/viewport';\nimport {ɵWorkbenchRouter} from '../../routing/ɵworkbench-router.service';\nimport {SciDimensionModule} from '@scion/components/dimension';\nimport {AsyncPipe, NgFor, NgIf} from '@angular/common';\nimport {PartActionBarComponent} from '../part-action-bar/part-action-bar.component';\nimport {ViewListButtonComponent} from '../view-list-button/view-list-button.component';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {fromDimension$} from '@scion/toolkit/observable';\nimport {WORKBENCH_ID} from '../../workbench-id';\nimport {ViewId} from '../../view/workbench-view.model';\n\n/**\n * Renders view tabs and actions of a {@link WorkbenchPart}.\n *\n * Tabs are added to a viewport, which the user can scroll if not enough space. The viewport grows with its tabs,\n * allowing actions to be placed directly after the last tab or on the right side.\n *\n * ## Drag Events\n * We use native drag and drop to support dragging views to other windows.\n *\n * By listening to drag events, the tabbar visualizes tabs during a drag operation. The drag operation is initiated in {@link ViewTabComponent}.\n * - `dragstart` and `dragend` events are fired in the tabbar where the drag operation was initiated.\n * - `dragenter` event is fired when a tab enters the tabbar.\n * - `dragover` events are fired when dragging a tab over the tabbar.\n * - `dragleave` event is fired when a tab leaves the tabbar.\n * - `drop` event is fired when the user drops a tab in the tabbar.\n * - Note that `dragleave` event is not fired on drop action. Therefore, always handle both events, `dragleave` and `drop` events, respectively.\n *\n * ## Terminology\n * - Drag source: Tab that is being dragged.\n * - Drop target: Tab before which to insert the drag source on drop, or `end` if dropping it after the last tab.\n * - Drag image:  Image for the tab to be dragged. We do not use the native drag image support to control drag image position and size,\n *                e.g., to snap the drag image to the tabbar when dragging near it.\n */\n@Component({\n  selector: 'wb-part-bar',\n  templateUrl: './part-bar.component.html',\n  styleUrls: ['./part-bar.component.scss'],\n  standalone: true,\n  imports: [\n    NgFor,\n    AsyncPipe,\n    SciViewportComponent,\n    SciDimensionModule,\n    ViewTabComponent,\n    PartActionBarComponent,\n    ViewListButtonComponent,\n    NgIf,\n  ],\n})\nexport class PartBarComponent implements OnInit {\n\n  private readonly _host: HTMLElement;\n  private readonly _viewportChange$ = new Subject<void>();\n  private readonly _viewTabs$ = new BehaviorSubject<ViewTabComponent[]>([]);\n  private readonly _dragenter$ = new Subject<void>();\n  private readonly _dragleave$ = new Subject<void>();\n  private readonly _dragend$ = new Subject<void>();\n  public readonly dragover$: Observable<boolean>;\n\n  @ViewChild(SciViewportComponent, {static: true, read: ElementRef})\n  private _viewportElement!: ElementRef<HTMLElement>;\n\n  @ViewChild(SciViewportComponent, {static: true})\n  private _viewportComponent!: SciViewportComponent;\n\n  @ViewChild('tab_corner_radius', {static: true})\n  private _tabCornerRadiusElement!: ElementRef<HTMLElement>;\n\n  @ViewChild('padding_inline', {static: true})\n  private _paddingInlineElement!: ElementRef<HTMLElement>;\n\n  @ViewChildren(ViewTabComponent)\n  public set injectViewTabs(queryList: QueryList<ViewTabComponent>) {\n    queryList.changes\n      .pipe(startWith(queryList), takeUntilDestroyed(this._destroyRef))\n      .subscribe(queryList => this._viewTabs$.next(queryList.toArray()));\n  }\n\n  /**\n   * Reference to the tab before which to insert the drag source on drop, or `end` if dropping it after the last tab.\n   */\n  public dropTargetViewTab: ViewTabComponent | 'end' | null = null;\n\n  /**\n   * Reference to the tab where the drag operation was started.\n   * This reference is only set if the drag operation started on a tab of this tabbar.\n   */\n  public dragSourceViewTab: ViewTabComponent | null = null;\n\n  /**\n   * Transfer data of the tab being dragged over this tabbar.\n   */\n  private _dragData: ViewDragData | null = null;\n\n  /**\n   * Function for snapping the drag image to the tabbar when dragging near it.\n   */\n  private _constrainFn: ConstrainFn | null = null;\n\n  /**\n   * Tabbar indents where to display the rounded bottom corners of the first and last view tab.\n   */\n  private _tabbarIndent = {\n    left: 0,\n    right: 0,\n  };\n\n  /**\n   * Notifies when the drag animation has finished, i.e., tabs have transitioned to their final position.\n   */\n  private _dragAnimationStable$ = interval(0, animationFrameScheduler)\n    .pipe(\n      filter(() => this.isDragAnimationStable()),\n      subscribeInside(continueFn => this._zone.runOutsideAngular(continueFn)),\n      observeInside(continueFn => this._zone.run(continueFn)),\n      map(() => undefined as void),\n    );\n\n  constructor(host: ElementRef<HTMLElement>,\n              @Inject(WORKBENCH_ID) private _workbenchId: string,\n              private _workbenchLayoutService: WorkbenchLayoutService,\n              private _router: ɵWorkbenchRouter,\n              private _viewTabDragImageRenderer: ViewTabDragImageRenderer,\n              private _part: ɵWorkbenchPart,\n              private _viewDragService: ViewDragService,\n              private _destroyRef: DestroyRef,\n              private _zone: NgZone) {\n    this._host = host.nativeElement;\n    this.dragover$ = this._viewDragService.tabbarDragOver$.pipe(map(partId => partId === this._part.id));\n  }\n\n  public ngOnInit(): void {\n    this.installActiveViewScroller();\n    this.installScrolledIntoViewUpdater();\n    this.installViewDragListener();\n    this.installTabbarIndentSizeDetector();\n    this.installViewportClientSizeDetector();\n  }\n\n  @HostListener('dblclick', ['$event'])\n  public onDoubleClick(event: MouseEvent): void {\n    if (this._part.isInMainArea) {\n      this._router.navigate(layout => layout.toggleMaximized()).then();\n    }\n    event.stopPropagation();\n  }\n\n  public get viewIds$(): Observable<ViewId[]> {\n    return this._part.viewIds$;\n  }\n\n  public onTabbarViewportDimensionChange(): void {\n    this._viewportChange$.next();\n  }\n\n  public onScroll(): void {\n    this._viewportChange$.next();\n  }\n\n  /**\n   * Method invoked when the user starts dragging a tab of this tabbar.\n   */\n  @HostListener('dragstart', ['$event'])\n  public onViewDragStart(event: DragEvent): void {\n    if (!this._viewDragService.isViewDragEvent(event)) {\n      return;\n    }\n\n    const dragData = this._viewDragService.viewDragData!;\n    const dragSourceIndex = this._viewTabs.findIndex(viewTab => viewTab.viewId === dragData.viewId);\n    const dragSourceViewTab = this._viewTabs[dragSourceIndex];\n    const dropTargetViewTab = this._viewTabs[dragSourceIndex + 1] ?? 'end';\n\n    // Constrain function for snapping the drag image to the tabbar when dragging near it.\n    this._constrainFn = this.createDragImageConstrainFn();\n    this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);\n    this._viewDragService.setTabbarDragover(this._part.id);\n\n    // When start dragging a view tab, we remove it from the tabbar by setting its `display` to `none` and render its drag image in `ViewTabDragImageRenderer` instead.\n    // However, do not unset the `display` of the drag source during `dragstart`. Otherwise, the native drag operation would be corrupted in Chrome and Edge (but not in Firefox).\n    animationFrameScheduler.schedule(() => {\n      this.dragSourceViewTab = dragSourceViewTab;\n      this.dropTargetViewTab = dropTargetViewTab; // Set drop target to avoid tab animation.\n      setCssVariable(this._host, {\n        '--ɵpart-bar-drag-source-width': `${dragData.viewTabWidth}px`,\n        '--ɵpart-bar-drag-image-placeholder-width': `${dragData.viewTabWidth}px`,\n      });\n    });\n\n    // When dragging a tab very quickly out of this tabbar, only the `dragstart` event gets fired, but not the `dragenter` event.\n    // Therefore, we subscribe to global `dragenter` events and manually invoke `onTabbarDragLeave` to correctly display the tabs and the active view.\n    this._viewDragService.viewDrag$(window, {eventType: ['dragenter']})\n      .pipe(take(1), takeUntil(this._dragend$), takeUntilDestroyed(this._destroyRef))\n      .subscribe(event => {\n        // Check if the user continues dragging over this tabbar.\n        // If not, the user has quickly dragged the tab out of the tabbar and we  manually call `onTabbarDragLeave`.\n        if ((this._host.compareDocumentPosition(event.target as Element) & Node.DOCUMENT_POSITION_CONTAINED_BY) === 0) {\n          this.onTabbarDragLeave();\n        }\n      });\n  }\n\n  /**\n   * Method invoked when the user ends dragging a tab of this tabbar.\n   *\n   * Invoked only in the tabbar where the drag operation started, regardless of whether the drag operation was completed or canceled.\n   */\n  @HostListener('dragend')\n  public onViewDragEnd(): void {\n    this._dragend$.next();\n    this.unsetDragState();\n  }\n\n  /**\n   * Method invoked when the user drags a tab into this tabbar.\n   */\n  private onTabbarDragEnter(event: DragEvent): void {\n    this._dragenter$.next();\n    this._viewDragService.setTabbarDragover(this._part.id);\n    this._dragData = this._viewDragService.viewDragData!;\n\n    // Constrain function for snapping the drag image to the tabbar when dragging near it.\n    if (!this._constrainFn) {\n      this._constrainFn = this.createDragImageConstrainFn();\n      this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);\n    }\n\n    // Locate drop target to have a nice animation for the drag source placeholder.\n    this.dropTargetViewTab = this.computeDropTarget(event);\n\n    // Set the CSS class 'drag-enter' to indicate entering the tabbar.\n    setCssClass(this._host, 'drag-enter', 'drag-over');\n    this._dragAnimationStable$\n      .pipe(take(1), takeUntil(this._dragenter$), takeUntilDestroyed(this._destroyRef))\n      .subscribe({complete: () => unsetCssClass(this._host, 'drag-enter')});\n\n    setCssVariable(this._host, {\n      '--ɵpart-bar-drag-source-width': `${this._dragData.viewTabWidth}px`,\n      '--ɵpart-bar-drag-image-placeholder-width': `${this._dragData.viewTabWidth}px`,\n    });\n  }\n\n  /**\n   * Method invoked when the user drags a tab out of this tabbar.\n   */\n  private onTabbarDragLeave(): void {\n    this._dragleave$.next();\n\n    // Set the CSS class 'drag-leave' to indicate leaving the tabbar.\n    setCssClass(this._host, 'drag-leave');\n    this._dragAnimationStable$\n      .pipe(take(1), takeUntil(this._dragleave$), takeUntilDestroyed(this._destroyRef))\n      .subscribe({complete: () => unsetCssClass(this._host, 'drag-leave')});\n\n    this.unsetDragState({unsetDragSource: false});\n\n    // Activate the view next to the view being dragged out of this tabbar. But, do not push the navigation into browsing history stack.\n    if (this.dragSourceViewTab && this.dragSourceViewTab.active) {\n      this._router.navigate(layout => layout.activateAdjacentView(this.dragSourceViewTab!.viewId), {skipLocationChange: true}).then();\n    }\n  }\n\n  /**\n   * Method invoked while the user is dragging a tab over this tabbar.\n   */\n  private onTabbarDragOver(event: DragEvent): void {\n    event.preventDefault(); // allow view drop\n\n    // Locate the tab over which the user is dragging the tab, but only after pending transitions have ended to prevent tabs from sliding back and forth.\n    if (this.isDragAnimationStable()) {\n      this.dropTargetViewTab = this.computeDropTarget(event);\n      // Synchronize the width of the drag source placeholder with the drag pointer position to move actions along with the pointer.\n      setCssVariable(this._host, {'--ɵpart-bar-drag-image-placeholder-width': `${this.calculateDragImagePlaceholderWidth(event)}px`});\n    }\n  }\n\n  /**\n   * Method invoked when the user drops a tab in this tabbar.\n   */\n  private onTabbarDrop(): void {\n    this._viewDragService.dispatchViewMoveEvent({\n      source: {\n        workbenchId: this._dragData!.workbenchId,\n        partId: this._dragData!.partId,\n        viewId: this._dragData!.viewId,\n        alternativeViewId: this._dragData!.alternativeViewId,\n        viewUrlSegments: this._dragData!.viewUrlSegments,\n        navigationHint: this._dragData!.navigationHint,\n        classList: this._dragData!.classList,\n      },\n      target: {\n        workbenchId: this._workbenchId,\n        position: this.dropTargetViewTab === 'end' ? 'end' : this._viewTabs.indexOf(this.dropTargetViewTab!),\n        elementId: this._part.id,\n      },\n    });\n\n    // Wait undoing the drag state until flushed tab changes to the DOM, i.e., after the layout routing cycle completes.\n    // If we were to undo the drag state immediately during the course of the drop event, the tab layout would temporarily\n    // revert to the state before the drag operation, resulting in an ugly flicker.\n    firstValueFrom(this._workbenchLayoutService.onLayoutChange$).then(() => {\n      this.unsetDragState();\n    });\n  }\n\n  /**\n   * Locates the tab before which the dragged tab is to be inserted when it is dropped. Dragging beyond the last tab returns `end`.\n   */\n  public computeDropTarget(event: DragEvent): ViewTabComponent | 'end' {\n    const viewDragImageRect = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData!, event);\n    const viewTabs = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab);\n\n    for (const viewTab of viewTabs) {\n      const viewTabRect = viewTab.host.getBoundingClientRect();\n      const viewTabMiddle = viewTabRect.left + (viewTabRect.width / 2);\n      if (viewDragImageRect.left < viewTabMiddle && (viewTab !== this.dropTargetViewTab || viewDragImageRect.right < viewTabMiddle)) {\n        return viewTab;\n      }\n    }\n    return 'end';\n  }\n\n  /**\n   * Creates the function for snapping the drag image to the tabbar when dragging near it.\n   */\n  private createDragImageConstrainFn(): ConstrainFn {\n    const hostLeft = this._host.getBoundingClientRect().left;\n    const maxViewportWidth = this.calculateMaxViewportWidth();\n    return (rect: ViewDragImageRect): ViewDragImageRect => {\n      const viewportBoundingBox = this._viewportElement.nativeElement.getBoundingClientRect();\n      return new ViewDragImageRect({\n        x: Math.min(Math.max(hostLeft + this._tabbarIndent.left, rect.x), hostLeft + maxViewportWidth - rect.width - this._tabbarIndent.right),\n        y: viewportBoundingBox.top,\n        width: rect.width,\n        height: viewportBoundingBox.height, // fit into tabbar, e.g., when dragging a tab into a tabbar of a different height\n      });\n    };\n  }\n\n  /**\n   * Calculates the maximum width of the tabbar viewport before an overflow would occur, which can then be used to constrain the drag image.\n   *\n   * To calculate the effective width, we need to simulate an overflow in the DOM. Therefore, call this method only from `dragstart` and not\n   * from `dragover` and disable animations.\n   */\n  private calculateMaxViewportWidth(): number {\n    const currentWidth = this._host.style.getPropertyValue('--ɵpart-bar-drag-image-placeholder-width');\n\n    // Disable animations during calculation and force the viewport to overflow.\n    setCssClass(this._host, 'calculating-max-viewport-width');\n    setCssVariable(this._host, {'--ɵpart-bar-drag-image-placeholder-width': `${this._host.clientWidth}px`});\n    try {\n      return this._viewportElement.nativeElement.getBoundingClientRect().width;\n    }\n    finally {\n      setCssVariable(this._host, {'--ɵpart-bar-drag-image-placeholder-width': currentWidth || null});\n      unsetCssClass(this._host, 'calculating-max-viewport-width');\n    }\n  }\n\n  /**\n   * Calculates the width for the drag image placeholder.\n   *\n   * - When dragging over tabs, the width is equal to the width of the drag source.\n   * - When dragging to the right of the last tab, the width of the placeholder is calculated as the distance between the\n   *   last tab and the position of the dragover event. Applying this width will resize the viewport, moving part actions along\n   *   with the dragover event.\n   */\n  private calculateDragImagePlaceholderWidth(event: DragEvent): number {\n    const viewDragImageRect = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData!, event);\n    const lastViewTab = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab).at(-1);\n    const lastViewTabRight = lastViewTab?.host.getBoundingClientRect().right ?? this._host.getBoundingClientRect().left + this._tabbarIndent.left;\n    return Math.max(lastViewTabRight + viewDragImageRect.width, viewDragImageRect.right) - lastViewTabRight;\n  }\n\n  /**\n   * Indicates whether CSS animations have finished when dragging a tab over the tabbar.\n   * The animation is considered stable when all tabs have moved to their final position.\n   */\n  private isDragAnimationStable(): boolean {\n    if (!this.dropTargetViewTab) {\n      return this._viewTabs.every(viewTab => getCssTranslation(viewTab.host).translateX === 'none');\n    }\n\n    const viewTabs = this._viewTabs.filter(viewTab => viewTab !== this.dragSourceViewTab);\n    const dropTargetIndex = this.dropTargetViewTab === 'end' ? viewTabs.length : viewTabs.indexOf(this.dropTargetViewTab!);\n    const dragSourceWidth = this._dragData!.viewTabWidth;\n\n    return viewTabs.every((viewTab, i) => {\n      const viewTabTranslateX = getCssTranslation(viewTab.host).translateX;\n      // Expect tabs preceding the drop target not to be shifted to the right.\n      if (i < dropTargetIndex && viewTabTranslateX !== 'none') {\n        return false;\n      }\n      // Expect drop target and tabs following the drop target to be shifted to the right.\n      if (i >= dropTargetIndex && Math.floor(Number(viewTabTranslateX)) !== Math.floor(dragSourceWidth)) { // compare floored numbers because `translateX` is not precise\n        return false;\n      }\n      return true;\n    });\n  }\n\n  private unsetDragState(options?: {unsetDragSource?: boolean}): void {\n    if (options?.unsetDragSource ?? true) {\n      this.dragSourceViewTab = null;\n    }\n\n    this.dropTargetViewTab = null;\n    this._dragData = null;\n    this._viewTabDragImageRenderer.unsetConstrainDragImageRectFn(this._constrainFn!);\n    this._constrainFn = null;\n\n    unsetCssClass(this._host, 'drag-over');\n    unsetCssVariable(this._host, '--ɵpart-bar-drag-source-width', '--ɵpart-bar-drag-image-placeholder-width');\n    this._viewDragService.unsetTabbarDragover(this._part.id);\n  }\n\n  private get _viewTabs(): ViewTabComponent[] {\n    return this._viewTabs$.value;\n  }\n\n  /**\n   * Scrolls the tab of the active view into view.\n   */\n  private installActiveViewScroller(): void {\n    this._viewTabs$\n      .pipe(\n        switchMap(viewTabs => combineLatest(viewTabs.map(viewTab => viewTab.view.active$))),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        // There may be no active view in the tabbar, e.g., when dragging the last view out of the tabbar.\n        const activeViewTab = this._viewTabs.find(viewTab => viewTab.active);\n        if (activeViewTab && !this._viewportComponent.isElementInView(activeViewTab.host, 'full')) {\n          this._viewportComponent.scrollIntoView(activeViewTab.host);\n        }\n      });\n  }\n\n  /**\n   * Updates {@link ɵWorkbenchView} when its tab is scrolled into view.\n   */\n  private installScrolledIntoViewUpdater(): void {\n    this._viewportChange$\n      .pipe(\n        map(() => this._viewTabs),\n        filterArray(viewTab => viewTab !== this.dragSourceViewTab), // skip drag source as always scrolled out of view\n        mergeMap(viewTabs => from(viewTabs)),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(viewTab => {\n        viewTab.view.scrolledIntoView = this._viewportComponent.isElementInView(viewTab.host, 'full');\n      });\n  }\n\n  private installViewDragListener(): void {\n    this._viewDragService.viewDrag$(this._host)\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((event: DragEvent) => {\n        switch (event.type) {\n          case 'dragenter':\n            this.onTabbarDragEnter(event);\n            break;\n          case 'dragover':\n            this.onTabbarDragOver(event);\n            break;\n          case 'dragleave':\n            this.onTabbarDragLeave();\n            break;\n          case 'drop':\n            this.onTabbarDrop();\n            break;\n        }\n      });\n  }\n\n  private installViewportClientSizeDetector(): void {\n    fromDimension$(this._viewportComponent.viewportClientElement)\n      .pipe(\n        subscribeInside(fn => this._zone.run(fn)),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => this._viewportChange$.next());\n  }\n\n  private installTabbarIndentSizeDetector(): void {\n    combineLatest([fromDimension$(this._tabCornerRadiusElement.nativeElement), fromDimension$(this._paddingInlineElement.nativeElement)])\n      .pipe(\n        subscribeInside(fn => this._zone.runOutsideAngular(fn)),\n        mapArray(dimension => dimension.clientWidth),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(([tabCornerRadius, paddingInline]) => {\n        this._tabbarIndent = {left: tabCornerRadius + paddingInline, right: tabCornerRadius + paddingInline};\n        setCssVariable(this._host, {'--ɵpart-bar-indent-left': `${this._tabbarIndent.left}px`});\n        setCssVariable(this._host, {'--ɵpart-bar-indent-right': `${this._tabbarIndent.right}px`});\n      });\n  }\n}\n","<sci-viewport class=\"tabbar\" scrollbarStyle=\"hidden\"\n              [class.dragover]=\"dragover$ | async\"\n              sciDimension (sciDimensionChange)=\"onTabbarViewportDimensionChange()\"\n              (scroll)=\"onScroll()\">\n  <ng-container *ngFor=\"let viewId of viewIds$ | async;\">\n    <div class=\"divider\" *ngIf=\"viewtab === dropTargetViewTab\"></div>\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab\">\n    </wb-view-tab>\n    <div class=\"divider\"></div>\n  </ng-container>\n\n  <!-- Placeholder element to grow the viewport to fit the drag image. -->\n  <div class=\"drag-image-placeholder\"></div>\n</sci-viewport>\n<wb-part-action-bar/>\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"part-bar.component.js","sourceRoot":"","sources":["../../../../../../../projects/scion/workbench/src/lib/part/part-bar/part-bar.component.ts","../../../../../../../projects/scion/workbench/src/lib/part/part-bar/part-bar.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2024 Swiss Federal Railways\n *\n * This program and the accompanying materials are made\n * available under the terms of the Eclipse Public License 2.0\n * which is available at https://www.eclipse.org/legal/epl-2.0/\n *\n * SPDX-License-Identifier: EPL-2.0\n */\n\nimport {Component, computed, effect, ElementRef, HostListener, inject, NgZone, OnDestroy, Signal, signal, untracked, viewChild, viewChildren} from '@angular/core';\nimport {ViewTabComponent} from '../view-tab/view-tab.component';\nimport {map, mergeMap, takeUntil} from 'rxjs/operators';\nimport {from, fromEvent, merge, Observable, OperatorFunction, Subject, timer} from 'rxjs';\nimport {ConstrainFn, ViewTabDragImageRenderer} from '../../view-dnd/view-tab-drag-image-renderer.service';\nimport {ViewDragData, ViewDragService, ViewMoveEvent} from '../../view-dnd/view-drag.service';\nimport {getCssTranslation, setCssClass, setCssVariable, unsetCssClass, unsetCssVariable} from '../../common/dom.util';\nimport {ɵWorkbenchPart} from '../ɵworkbench-part.model';\nimport {filterArray, subscribeIn} from '@scion/toolkit/operators';\nimport {SciViewportComponent} from '@scion/components/viewport';\nimport {ɵWorkbenchRouter} from '../../routing/ɵworkbench-router.service';\nimport {boundingClientRect, dimension} from '@scion/components/dimension';\nimport {PartActionBarComponent} from '../part-action-bar/part-action-bar.component';\nimport {ViewListButtonComponent} from '../view-list-button/view-list-button.component';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {WORKBENCH_ID} from '../../workbench-id';\nimport {clamp} from '../../common/math.util';\n\n/**\n * Renders view tabs and actions of a {@link WorkbenchPart}.\n *\n * Tabs are added to a viewport, which the user can scroll if not enough space. The viewport grows with its tabs,\n * allowing actions to be placed directly after the last tab or on the right side.\n *\n * ## Drag and Drop\n * This component subscribes to drag events to visualize tabs during a drag operation. The drag operation is initiated in {@link ViewTabComponent}.\n *\n * We use native drag and drop to support dragging views to other windows.\n *\n * Following events are triggered:\n * - dragstart: when start dragging a tab (only received in the tabbar where the drag operation has started)\n * - dragend:   when end dragging a tab, either via drop or cancel (only received in the tabbar where the drag operation has started)\n * - dragenter: when a tab enters the tabbar\n * - dragover:  when dragging a tab over the tabbar, every few hundred milliseconds\n * - dragleave: when a tab leaves the tabbar\n * - drop:      when the user drops a tab in the tabbar\n *\n * - Note that `dragleave` event is not fired on drop action. Therefore, always handle both events, `dragleave` and `drop` events, respectively.\n *\n * ## Terminology\n * - Drag source: Tab that is being dragged.\n * - Drop target: Tab before which to insert the drag source on drop, or `end` if dropping it after the last tab.\n * - Drag image:  Image for the tab to be dragged. We do not use the native drag image support to control drag image position and size,\n *                e.g., to snap the drag image to the tabbar when dragging near it.\n */\n@Component({\n  selector: 'wb-part-bar',\n  templateUrl: './part-bar.component.html',\n  styleUrls: ['./part-bar.component.scss'],\n  standalone: true,\n  imports: [\n    SciViewportComponent,\n    ViewTabComponent,\n    PartActionBarComponent,\n    ViewListButtonComponent,\n  ],\n})\nexport class PartBarComponent implements OnDestroy {\n\n  private readonly _host = inject(ElementRef<HTMLElement>).nativeElement;\n  private readonly _viewportChange$ = new Subject<void>();\n  private readonly _workbenchId = inject(WORKBENCH_ID);\n  private readonly _router = inject(ɵWorkbenchRouter);\n  private readonly _viewTabDragImageRenderer = inject(ViewTabDragImageRenderer);\n  private readonly _viewDragService = inject(ViewDragService);\n  private readonly _zone = inject(NgZone);\n\n  private readonly _viewTabs = viewChildren(ViewTabComponent);\n  private readonly _hostBoundingClientRect = boundingClientRect(inject(ElementRef));\n  private readonly _viewportComponent = viewChild.required(SciViewportComponent);\n  private readonly _viewportComponentElement = viewChild.required(SciViewportComponent, {read: ElementRef<HTMLElement>});\n  private readonly _tabCornerRadiusElement = viewChild.required('tab_corner_radius', {read: ElementRef<HTMLElement>});\n  private readonly _paddingInlineElement = viewChild.required('padding_inline', {read: ElementRef<HTMLElement>});\n  private readonly _fillerElement = viewChild.required<ElementRef<HTMLElement>>('filler');\n  private readonly _viewportBoundingBox = boundingClientRect(this._viewportComponentElement);\n  private readonly _maxViewportWidth: Signal<number>;\n\n  protected readonly part = inject(ɵWorkbenchPart);\n  protected readonly startActions = computed(() => this.part.actions().filter(action => action.align !== 'end'));\n  protected readonly endActions = computed(() => this.part.actions().filter(action => action.align === 'end'));\n\n  /**\n   * Reference to the tab before which to insert the drag source on drop, or `end` if dropping it after the last tab.\n   */\n  protected dropTargetViewTab = signal<ViewTabComponent | 'end' | null>(null);\n\n  /**\n   * Reference to the tab where the drag operation was started.\n   * This reference is only set if the drag operation started on a tab of this tabbar.\n   */\n  protected dragSourceViewTab = signal<ViewTabComponent | null>(null);\n\n  /**\n   * Transfer data of the tab being dragged over this tabbar.\n   */\n  private _dragData: ViewDragData | null = null;\n\n  /**\n   * Function for snapping the drag image to the tabbar when dragging near it.\n   */\n  private _constrainFn: ConstrainFn | null = null;\n\n  /**\n   * Signals when unsetting drag state.\n   */\n  private _onUnsetDragState = signal<void>(undefined, {equal: () => false});\n\n  /**\n   * Tabbar indents where to display the rounded bottom corners of the first and last view tab.\n   */\n  private _tabbarIndent = {\n    left: 0,\n    right: 0,\n  };\n\n  constructor() {\n    this._maxViewportWidth = this.calculateMaxViewportWidth();\n    this.installActiveViewScroller();\n    this.installScrolledIntoViewUpdater();\n    this.installViewDragListener();\n    this.installTabbarIndentSizeTracker();\n    this.installViewportChangeTracker();\n  }\n\n  @HostListener('dblclick', ['$event'])\n  protected onDoubleClick(event: MouseEvent): void {\n    if (this.part.isInMainArea) {\n      this._router.navigate(layout => layout.toggleMaximized()).then();\n    }\n    event.stopPropagation();\n  }\n\n  /**\n   * Method invoked when the user starts dragging a tab of this tabbar, only in the tabbar where the drag started.\n   */\n  private onTabDragStart(): void {\n    // Memoize drag data.\n    this._dragData = this._viewDragService.viewDragData()!;\n\n    // Indicate dragging over this tabbar.\n    this._viewDragService.signalTabbarDragEnter(this.part.id);\n\n    // Snap drag image to tabbar when dragging near it.\n    this._constrainFn = this.createDragImageConstrainFn();\n    this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);\n\n    // Disable pointer events to not break the drag operation (in Firefox, but not Chrome and Edge).\n    requestAnimationFrame(() => setCssClass(this._host, 'pointer-events-disabled'));\n\n    // Set CSS class to not animate start dragging.\n    setCssClass(this._host, 'on-drag-start');\n    this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-start'));\n\n    // Check if the user continues dragging over this tabbar.\n    // If not, the user has quickly dragged the tab out of the tabbar, so manually call `onTabbarDragEnter` and `onTabbarDragLeave`.\n    fromEvent<DragEvent>(window, 'dragenter', {once: true})\n      .pipe(takeUntil(merge(fromEvent(this._host, 'dragenter'), fromEvent(this._host, 'dragend'))))\n      .subscribe(event => {\n        this.onTabbarDragEnter(event);\n        this.onTabbarDragLeave(event);\n      });\n  }\n\n  /**\n   * Method invoked when the user ends dragging a tab of this tabbar, either by drop or cancel, only in the tabbar where the drag started.\n   */\n  private onTabDragEnd(event: DragEvent): void {\n    // Unset drag state only on cancel, not on drop, to prevent tabs from temporarily reverting to their pre-drag state. Drag state is reset in `onTabMoved` after a drop.\n    if (event.dataTransfer!.dropEffect === 'none') {\n      // Reactivate the drag source view on cancel.\n      this.dragSourceViewTab()?.view().activate({skipLocationChange: true}).then();\n      // Unset drag state.\n      this.unsetDragState();\n    }\n  }\n\n  /**\n   * Method invoked when the layout has changed after a drop. The drop may not be related to a tab of this tabbar.\n   */\n  private onTabMoved(event: ViewMoveEvent): void {\n    // Unset drag state only if no new drag has started since the drop.\n    if (this._dragData?.uid === event.dragData?.uid) {\n      this.unsetDragState();\n    }\n  }\n\n  /**\n   * Method invoked when the user drags a tab into this tabbar.\n   */\n  private onTabbarDragEnter(event: DragEvent): void {\n    // Memoize drag data.\n    const dragData = this._dragData = this._viewDragService.viewDragData()!;\n\n    // Indicate dragging over this tabbar.\n    this._viewDragService.signalTabbarDragEnter(this.part.id);\n\n    // Snap drag image to tabbar when dragging near it.\n    this._constrainFn = this.createDragImageConstrainFn();\n    this._viewTabDragImageRenderer.setConstrainDragImageRectFn(this._constrainFn);\n\n    // Set drag source, but only if started the drag operation in this part.\n    // We do not set the drag source in `dragstart` to not break the drag operation (in Chrome and Edge, but not Firefox).\n    if (this._host.classList.contains('on-drag-start')) {\n      this.dragSourceViewTab.set(this._viewTabs().find(viewTab => viewTab.viewId === dragData.viewId) ?? null);\n      setCssVariable(this._host, {'--ɵpart-bar-drag-placeholder-width': `${dragData.viewTabWidth}px`});\n    }\n\n    // Locate the tab the user is dragging over.\n    this.dropTargetViewTab.set(this.computeDropTarget(event));\n\n    // Disable pointer events on the tabbar for a smoother drag and drop experience when quickly swapping tabs.\n    setCssClass(this._host, 'pointer-events-disabled');\n\n    // Set CSS class to animate entering the tabbar.\n    setCssClass(this._host, 'on-drag-enter');\n    this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-enter'));\n\n    // Inject drag source width into CSS.\n    setCssVariable(this._host, {'--ɵpart-bar-drag-source-width': `${dragData.viewTabWidth}px`});\n  }\n\n  /**\n   * Method invoked when the user drags a tab out of this tabbar.\n   */\n  private onTabbarDragLeave(event: DragEvent): void {\n    // Set CSS class to animate leaving the tabbar, but not when canceling the drag operation for instant reset.\n    // Pointer coordinates are not set when the drag operation is canceled or when dragging the tab out of the window.\n    if (event.screenX || event.screenY) {\n      setCssClass(this._host, 'on-drag-leave');\n      this.onDragAnimationStable(() => unsetCssClass(this._host, 'on-drag-leave'));\n    }\n\n    // Activate the adjacent tab, only if the drag operation is not canceled.\n    // The drag event does not provide information about cancelation. Therefore, we wait for a macrotask, canceling it when receiving `dragend`, i.e., the drag operation has been canceled.\n    if (this.dragSourceViewTab()?.active) {\n      timer(0)\n        .pipe(takeUntil(fromEvent(window, 'dragend')))\n        .subscribe(() => this._router.navigate(layout => layout.activateAdjacentView(this.dragSourceViewTab()!.viewId), {skipLocationChange: true}));\n    }\n\n    // Clean up drag state.\n    this.unsetDragState({unsetDragSource: false, unsetDragData: false});\n  }\n\n  /**\n   * Method invoked when the user is dragging a tab over this tabbar.\n   */\n  private onTabbarDragOver(event: DragEvent, dragDistance: number, scrollDistance: number): void {\n    NgZone.assertNotInAngularZone();\n    event.preventDefault(); // allow view drop\n\n    // Locate the tab the user is dragging over.\n    // - Run in animation frame for better performance, most noticeable on lower CPU power.\n    // - Do not wait for the drag animation to complete for a smoother drag and drop experience when quickly moving the tab in the tabbar.\n    requestAnimationFrame(() => {\n      // Skip if the drag operation has ended.\n      if (this._viewDragService.isDragOverTabbar !== this.part.id) {\n        return;\n      }\n\n      // Ignore the drag distance if `drag-enter` animation is in progress to avoid incorrect drop target computation when dragging a tab from the left.\n      if (this._host.classList.contains('on-drag-enter')) {\n        this.dropTargetViewTab.set(this.computeDropTarget(event, 0));\n      }\n      // Compute drop target only when moving the drag pointer to prevent tabs from sliding back and forth (while animation is in progress)\n      else if (dragDistance) {\n        this.dropTargetViewTab.set(this.computeDropTarget(event, dragDistance));\n      }\n      // Compute drop target when scrolling the viewport, i.e., not moving the drag pointer but scrolling the viewport because placed the drag pointer at the viewport edges.\n      else if (scrollDistance) {\n        this.dropTargetViewTab.set(this.computeDropTarget(event, scrollDistance));\n      }\n\n      // Set CSS class to animate dragging over the tabbar.\n      setCssClass(this._host, 'drag-over');\n\n      // Calculate the new size of the drag source placeholder.\n      // The placeholder expands the viewport when dragging a tab to the right, moving part actions along with the dragover event.\n      setCssVariable(this._host, {'--ɵpart-bar-drag-placeholder-width': `${this.calculateDragPlaceholderWidth(event)}px`});\n    });\n  }\n\n  /**\n   * Method invoked when the user drops a tab in this tabbar.\n   */\n  private async onTabbarDrop(): Promise<void> {\n    const dragData = this._dragData!;\n    const dropTargetViewTab = this.dropTargetViewTab()!;\n    const dropPosition = dropTargetViewTab === 'end' ? 'end' : this._viewTabs().indexOf(dropTargetViewTab);\n\n    this._viewDragService.dispatchViewMoveEvent({\n      source: {\n        workbenchId: dragData.workbenchId,\n        partId: dragData.partId,\n        viewId: dragData.viewId,\n        alternativeViewId: dragData.alternativeViewId,\n        viewUrlSegments: dragData.viewUrlSegments,\n        navigationHint: dragData.navigationHint,\n        navigationData: dragData.navigationData,\n        classList: dragData.classList,\n      },\n      target: {\n        workbenchId: this._workbenchId,\n        position: dropPosition,\n        elementId: this.part.id,\n      },\n      dragData: dragData,\n    });\n  }\n\n  /**\n   * Locates the tab before which the dragged tab is to be inserted when it is dropped. Dragging beyond the last tab returns `end`.\n   */\n  private computeDropTarget(event: DragEvent, dragDistanceX = 0): ViewTabComponent | 'end' {\n    const dragImage = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData!, event);\n    const viewTabs = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab());\n\n    for (const viewTab of viewTabs) {\n      const {left, width} = viewTab.boundingClientRect();\n      const viewTabHCenter = left + (width / 2);\n\n      // Moving the pointer to the left.\n      if (dragDistanceX <= 0 && dragImage.left < viewTabHCenter) {\n        return viewTab;\n      }\n      // Moving the pinter to the right.\n      if (dragDistanceX > 0 && dragImage.right < viewTabHCenter) {\n        return viewTab;\n      }\n    }\n    return 'end';\n  }\n\n  /**\n   * Creates the function for snapping the drag image to the tabbar when dragging near it.\n   */\n  private createDragImageConstrainFn(): ConstrainFn {\n    return (dragImage: DOMRect): DOMRect => new DOMRect(\n      clamp(dragImage.x, {\n        min: this._hostBoundingClientRect().left + this._tabbarIndent.left,\n        max: this._hostBoundingClientRect().left + this._maxViewportWidth() - dragImage.width - this._tabbarIndent.right,\n      }),\n      this._viewportBoundingBox().top,\n      dragImage.width,\n      this._viewportBoundingBox().height, // fit into tabbar, e.g., when dragging a tab into a tabbar of a different height\n    );\n  }\n\n  /**\n   * Calculates the maximum width of the tabbar viewport before an overflow would occur.\n   * Use to constrain the drag image to the tabbar bounds.\n   */\n  private calculateMaxViewportWidth(): Signal<number> {\n    const fillerDimension = dimension(this._fillerElement);\n    return computed(() => this._viewportBoundingBox().width + fillerDimension().offsetWidth);\n  }\n\n  /**\n   * Calculates the width for the drag placeholder.\n   *\n   * The placeholder expands the viewport when dragging a tab to the right, moving part actions along with the dragover event.\n   *\n   * Calculation:\n   * - When dragging over tabs, the width is equal to the width of the drag source.\n   * - When dragging to the right of the last tab, the width of the placeholder is the distance between the last tab and the position of the drag pointer.\n   */\n  private calculateDragPlaceholderWidth(event: DragEvent): number {\n    const viewDragImageRect = this._viewTabDragImageRenderer.calculateDragImageRect(this._dragData!, event);\n    const lastViewTab = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab()).at(-1);\n    const lastViewTabRight = lastViewTab?.boundingClientRect().right ?? this._hostBoundingClientRect().left + this._tabbarIndent.left;\n    return Math.max(lastViewTabRight + viewDragImageRect.width, viewDragImageRect.right) - lastViewTabRight;\n  }\n\n  /**\n   * Indicates whether CSS animations have finished when dragging a tab over the tabbar.\n   * The animation is considered stable when all tabs have moved to their final position.\n   */\n  private isDragAnimationStable(): boolean {\n    const dropTargetViewTab = this.dropTargetViewTab();\n    if (this._viewDragService.isDragOverTabbar !== this.part.id) {\n      return this._viewTabs().every(viewTab => getCssTranslation(viewTab.host).translateX === 'none');\n    }\n\n    const viewTabs = this._viewTabs().filter(viewTab => viewTab !== this.dragSourceViewTab());\n    const dropTargetIndex = dropTargetViewTab === 'end' ? viewTabs.length : viewTabs.indexOf(dropTargetViewTab!);\n    const dragSourceWidth = this._dragData!.viewTabWidth;\n\n    return viewTabs.every((viewTab, i) => {\n      const viewTabTranslateX = getCssTranslation(viewTab.host).translateX;\n      // Expect tabs preceding the drop target not to be shifted to the right.\n      if (i < dropTargetIndex && viewTabTranslateX !== 'none') {\n        return false;\n      }\n      // Expect drop target and tabs following the drop target to be shifted to the right.\n      if (i >= dropTargetIndex && Math.floor(Number(viewTabTranslateX)) !== Math.floor(dragSourceWidth)) { // compare floored numbers because `translateX` is not precise\n        return false;\n      }\n      return true;\n    });\n  }\n\n  /**\n   * Cleans up the drag state, unsetting drag data and drag source based on provided options.\n   */\n  private unsetDragState(options?: {unsetDragSource?: false; unsetDragData?: false}): void {\n    this.dropTargetViewTab.set(null);\n    this._onUnsetDragState.set();\n    this._viewTabDragImageRenderer.unsetConstrainDragImageRectFn(this._constrainFn!);\n    this._viewDragService.signalTabbarDragLeave(this.part.id);\n    this._constrainFn = null;\n\n    unsetCssClass(this._host, 'drag-over', 'pointer-events-disabled');\n    unsetCssVariable(this._host, '--ɵpart-bar-drag-source-width', '--ɵpart-bar-drag-placeholder-width');\n\n    if (options?.unsetDragSource ?? true) {\n      this.dragSourceViewTab.set(null);\n    }\n    if (options?.unsetDragData ?? true) {\n      this._dragData = null;\n    }\n  }\n\n  /**\n   * Executes given function when the drag animation has finished, i.e., tabs have transitioned to their final position.\n   */\n  private onDragAnimationStable(callback: () => void): void {\n    if (NgZone.isInAngularZone()) {\n      this._zone.runOutsideAngular(() => this.onDragAnimationStable(callback));\n      return;\n    }\n    requestAnimationFrame(() => this.isDragAnimationStable() ? callback() : this.onDragAnimationStable(callback));\n  }\n\n  /**\n   * Scrolls the tab of the active view into view.\n   */\n  private installActiveViewScroller(): void {\n    effect(() => {\n      // Track the active view.\n      const activeViewId = this.part.activeViewId();\n      // There may be no active view, e.g., if no view has been activated, or when dragging the last view out of the tabbar.\n      if (!activeViewId) {\n        return;\n      }\n\n      // Do not track rendered tabs in general to prevent unwanted scrolling when opening or closing inactive tabs.\n      const viewTabs = untracked(() => this._viewTabs());\n\n      // Get a reference to the currently rendered active tab, waiting if necessary by tracking the rendered tabs.\n      const activeViewTab = viewTabs.find(viewTab => viewTab.viewId === activeViewId);\n      if (!activeViewTab) {\n        this._viewTabs(); // Track rendered tabs to re-execute once rendered.\n        return;\n      }\n\n      // Track navigation of the active view, scrolling its tab into view if necessary.\n      activeViewTab.view().navigationId();\n\n      // Track unsetting drag state to ensure the active view is scrolled into view after drop or cancel.\n      this._onUnsetDragState();\n\n      // Scroll the tab into view if scrolled out of view.\n      untracked(() => requestAnimationFrame(() => {\n        if (!this._viewportComponent().isElementInView(activeViewTab.host, 'full')) {\n          this._viewportComponent().scrollIntoView(activeViewTab.host);\n        }\n      }));\n    });\n  }\n\n  /**\n   * Updates {@link ɵWorkbenchView} when its tab is scrolled into view.\n   */\n  private installScrolledIntoViewUpdater(): void {\n    this._viewportChange$\n      .pipe(\n        map(() => this._viewTabs()),\n        filterArray(viewTab => viewTab !== this.dragSourceViewTab()), // skip drag source as always scrolled out of view\n        mergeMap(viewTabs => from(viewTabs)),\n        takeUntilDestroyed(),\n      )\n      .subscribe(viewTab => {\n        viewTab.view().scrolledIntoView = this._viewportComponent().isElementInView(viewTab.host, 'full');\n      });\n  }\n\n  /**\n   * Subscribes to drag events.\n   */\n  private installViewDragListener(): void {\n    const zone = inject(NgZone);\n\n    // Subscribe to drag events relevant for this tabbar.\n    this._viewDragService.viewDrag$(this._host)\n      .pipe(\n        subscribeIn(fn => zone.runOutsideAngular(fn)),\n        calculateDistance(() => this._viewportComponent()), // provide viewport lazily because not injected yet\n        takeUntilDestroyed(),\n      )\n      .subscribe(({event, dragDistance, scrollDistance}) => {\n        switch (event.type) {\n          case 'dragstart':\n            this.onTabDragStart();\n            break;\n          case 'dragend':\n            this.onTabDragEnd(event);\n            break;\n          case 'dragenter':\n            this.onTabbarDragEnter(event);\n            break;\n          case 'dragover':\n            this.onTabbarDragOver(event, dragDistance, scrollDistance);\n            break;\n          case 'dragleave':\n            this.onTabbarDragLeave(event);\n            break;\n          case 'drop':\n            this.onTabbarDrop().then();\n            break;\n        }\n      });\n\n    // Get notified when a view has moved in the layout.\n    this._viewDragService.viewMoved$\n      .pipe(\n        subscribeIn(fn => zone.runOutsideAngular(fn)),\n        takeUntilDestroyed(),\n      )\n      .subscribe(event => this.onTabMoved(event));\n\n    /**\n     * Calculates the distance the drag pointer and viewport have moved since the last drag event.\n     */\n    function calculateDistance(viewport: () => SciViewportComponent): OperatorFunction<DragEvent, DragEventPlusDistance> {\n      return source$ => new Observable<DragEventPlusDistance>(observer => {\n        let lastScreenX: number | undefined;\n        let lastScrollLeft: number | undefined;\n\n        const subscription = source$.subscribe(event => {\n          observer.next({\n            event,\n            dragDistance: event.screenX - (lastScreenX ?? event.screenX),\n            scrollDistance: viewport().scrollLeft - (lastScrollLeft ?? viewport().scrollLeft),\n          });\n          lastScreenX = event.screenX;\n          lastScrollLeft = viewport().scrollLeft;\n        });\n        return () => subscription.unsubscribe();\n      });\n    }\n  }\n\n  /**\n   * Emits on {@link _viewportChange$} when the viewport size or scroll position changes.\n   */\n  private installViewportChangeTracker(): void {\n    const viewportSize = dimension(computed(() => this._viewportComponentElement().nativeElement));\n    const viewportClientSize = dimension(computed(() => this._viewportComponent().viewportClientElement));\n    const zone = inject(NgZone);\n\n    // Detect resizing.\n    effect(() => {\n      // Track viewport and viewport client sizes.\n      viewportSize();\n      viewportClientSize();\n      untracked(() => this._viewportChange$.next());\n    });\n\n    // Detect scrolling.\n    effect(onCleanup => {\n      const viewport = this._viewportComponent().viewportElement;\n      untracked(() => {\n        const subscription = fromEvent(viewport, 'scroll')\n          .pipe(subscribeIn(fn => zone.runOutsideAngular(fn)))\n          .subscribe(() => this._viewportChange$.next());\n        onCleanup(() => subscription.unsubscribe());\n      });\n    });\n  }\n\n  /**\n   * Tracks the tabbar indents.\n   */\n  private installTabbarIndentSizeTracker(): void {\n    const tabCornerRadiusDimension = dimension(this._tabCornerRadiusElement);\n    const paddingInlineDimension = dimension(this._paddingInlineElement);\n\n    effect(() => {\n      const indent = tabCornerRadiusDimension().clientWidth + paddingInlineDimension().clientWidth;\n      this._tabbarIndent = {left: indent, right: indent};\n      setCssVariable(this._host, {\n        '--ɵpart-bar-indent-left': `${this._tabbarIndent.left}px`,\n        '--ɵpart-bar-indent-right': `${this._tabbarIndent.right}px`,\n      });\n    });\n  }\n\n  public ngOnDestroy(): void {\n    this.unsetDragState();\n  }\n}\n\n/**\n * Contains the event plus drag and scroll distance.\n */\ninterface DragEventPlusDistance {\n  /**\n   * Reference to the drag event.\n   */\n  event: DragEvent;\n  /**\n   * Distance the drag pointer has moved since the last drag event.\n   */\n  dragDistance: number;\n  /**\n   * Distance the viewport has scrolled since the last drag event.\n   */\n  scrollDistance: number;\n}\n","<sci-viewport class=\"tabbar e2e-tabbar\" scrollbarStyle=\"hidden\">\n  @for (viewId of part.viewIds(); track viewId) {\n    @if (viewtab === dropTargetViewTab()) {\n      <div class=\"divider\"></div>\n    }\n    <wb-view-tab #viewtab\n                 [viewId]=\"viewId\"\n                 [class.drag-source]=\"viewtab === dragSourceViewTab()\"\n                 [class.drop-target]=\"viewtab === dropTargetViewTab()\"/>\n    <div class=\"divider\"></div>\n  }\n\n  <!-- Placeholder for expanding the viewport when dragging a tab to the right, moving part actions along with the dragover event. -->\n  <div class=\"drag-placeholder\"></div>\n</sci-viewport>\n\n<!-- Actions -->\n@if (startActions().length) {\n  <wb-part-action-bar [actions]=\"startActions()\" class=\"start\"/>\n}\n<div class=\"filler\" #filler></div>\n@if (endActions().length) {\n  <wb-part-action-bar [actions]=\"endActions()\" class=\"end\"/>\n}\n\n<!-- View List Dropdown -->\n<wb-view-list-button/>\n\n<!-- Element for injecting the corner radius into the component. -->\n<div class=\"tab-corner-radius\" #tab_corner_radius></div>\n<!-- Element for injecting the tabbar padding into the component. -->\n<div class=\"padding-inline\" #padding_inline></div>\n"]}