@angular/cdk 17.0.2 → 17.1.0-next.1

package/fesm2022/drag-drop.mjs

@@ -1813,6 +1813,20 @@ const DROP_PROXIMITY_THRESHOLD = 0.05;
  * viewport. The value comes from trying it out manually until it feels right.
  */
 const SCROLL_PROXIMITY_THRESHOLD = 0.05;
+/** Vertical direction in which we can auto-scroll. */
+var AutoScrollVerticalDirection;
+(function (AutoScrollVerticalDirection) {
+    AutoScrollVerticalDirection[AutoScrollVerticalDirection["NONE"] = 0] = "NONE";
+    AutoScrollVerticalDirection[AutoScrollVerticalDirection["UP"] = 1] = "UP";
+    AutoScrollVerticalDirection[AutoScrollVerticalDirection["DOWN"] = 2] = "DOWN";
+})(AutoScrollVerticalDirection || (AutoScrollVerticalDirection = {}));
+/** Horizontal direction in which we can auto-scroll. */
+var AutoScrollHorizontalDirection;
+(function (AutoScrollHorizontalDirection) {
+    AutoScrollHorizontalDirection[AutoScrollHorizontalDirection["NONE"] = 0] = "NONE";
+    AutoScrollHorizontalDirection[AutoScrollHorizontalDirection["LEFT"] = 1] = "LEFT";
+    AutoScrollHorizontalDirection[AutoScrollHorizontalDirection["RIGHT"] = 2] = "RIGHT";
+})(AutoScrollHorizontalDirection || (AutoScrollHorizontalDirection = {}));
 /**
  * Reference to a drop list. Used to manipulate or dispose of the container.
  */
@@ -1869,9 +1883,9 @@ class DropListRef {
         /** Subscription to the window being scrolled. */
         this._viewportScrollSubscription = Subscription.EMPTY;
         /** Vertical direction in which the list is currently scrolling. */
-        this._verticalScrollDirection = 0 /* AutoScrollVerticalDirection.NONE */;
+        this._verticalScrollDirection = AutoScrollVerticalDirection.NONE;
         /** Horizontal direction in which the list is currently scrolling. */
-        this._horizontalScrollDirection = 0 /* AutoScrollHorizontalDirection.NONE */;
+        this._horizontalScrollDirection = AutoScrollHorizontalDirection.NONE;
         /** Used to signal to the current auto-scroll sequence when to stop. */
         this._stopScrollTimers = new Subject();
         /** Shadow root of the current element. Necessary for `elementFromPoint` to resolve correctly. */
@@ -1884,16 +1898,16 @@ class DropListRef {
                 .subscribe(() => {
                 const node = this._scrollNode;
                 const scrollStep = this.autoScrollStep;
-                if (this._verticalScrollDirection === 1 /* AutoScrollVerticalDirection.UP */) {
+                if (this._verticalScrollDirection === AutoScrollVerticalDirection.UP) {
                     node.scrollBy(0, -scrollStep);
                 }
-                else if (this._verticalScrollDirection === 2 /* AutoScrollVerticalDirection.DOWN */) {
+                else if (this._verticalScrollDirection === AutoScrollVerticalDirection.DOWN) {
                     node.scrollBy(0, scrollStep);
                 }
-                if (this._horizontalScrollDirection === 1 /* AutoScrollHorizontalDirection.LEFT */) {
+                if (this._horizontalScrollDirection === AutoScrollHorizontalDirection.LEFT) {
                     node.scrollBy(-scrollStep, 0);
                 }
-                else if (this._horizontalScrollDirection === 2 /* AutoScrollHorizontalDirection.RIGHT */) {
+                else if (this._horizontalScrollDirection === AutoScrollHorizontalDirection.RIGHT) {
                     node.scrollBy(scrollStep, 0);
                 }
             });
@@ -2102,8 +2116,8 @@ class DropListRef {
             return;
         }
         let scrollNode;
-        let verticalScrollDirection = 0 /* AutoScrollVerticalDirection.NONE */;
-        let horizontalScrollDirection = 0 /* AutoScrollHorizontalDirection.NONE */;
+        let verticalScrollDirection = AutoScrollVerticalDirection.NONE;
+        let horizontalScrollDirection = AutoScrollHorizontalDirection.NONE;
         // Check whether we should start scrolling any of the parent containers.
         this._parentPositions.positions.forEach((position, element) => {
             // We have special handling for the `document` below. Also this would be
@@ -2313,12 +2327,12 @@ function getVerticalScrollDirection(clientRect, pointerY) {
     const { top, bottom, height } = clientRect;
     const yThreshold = height * SCROLL_PROXIMITY_THRESHOLD;
     if (pointerY >= top - yThreshold && pointerY <= top + yThreshold) {
-        return 1 /* AutoScrollVerticalDirection.UP */;
+        return AutoScrollVerticalDirection.UP;
     }
     else if (pointerY >= bottom - yThreshold && pointerY <= bottom + yThreshold) {
-        return 2 /* AutoScrollVerticalDirection.DOWN */;
+        return AutoScrollVerticalDirection.DOWN;
     }
-    return 0 /* AutoScrollVerticalDirection.NONE */;
+    return AutoScrollVerticalDirection.NONE;
 }
 /**
  * Gets whether the horizontal auto-scroll direction of a node.
@@ -2329,12 +2343,12 @@ function getHorizontalScrollDirection(clientRect, pointerX) {
     const { left, right, width } = clientRect;
     const xThreshold = width * SCROLL_PROXIMITY_THRESHOLD;
     if (pointerX >= left - xThreshold && pointerX <= left + xThreshold) {
-        return 1 /* AutoScrollHorizontalDirection.LEFT */;
+        return AutoScrollHorizontalDirection.LEFT;
     }
     else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {
-        return 2 /* AutoScrollHorizontalDirection.RIGHT */;
+        return AutoScrollHorizontalDirection.RIGHT;
     }
-    return 0 /* AutoScrollHorizontalDirection.NONE */;
+    return AutoScrollHorizontalDirection.NONE;
 }
 /**
  * Gets the directions in which an element node should be scrolled,
@@ -2347,32 +2361,32 @@ function getHorizontalScrollDirection(clientRect, pointerX) {
 function getElementScrollDirections(element, clientRect, pointerX, pointerY) {
     const computedVertical = getVerticalScrollDirection(clientRect, pointerY);
     const computedHorizontal = getHorizontalScrollDirection(clientRect, pointerX);
-    let verticalScrollDirection = 0 /* AutoScrollVerticalDirection.NONE */;
-    let horizontalScrollDirection = 0 /* AutoScrollHorizontalDirection.NONE */;
+    let verticalScrollDirection = AutoScrollVerticalDirection.NONE;
+    let horizontalScrollDirection = AutoScrollHorizontalDirection.NONE;
     // Note that we here we do some extra checks for whether the element is actually scrollable in
     // a certain direction and we only assign the scroll direction if it is. We do this so that we
     // can allow other elements to be scrolled, if the current element can't be scrolled anymore.
     // This allows us to handle cases where the scroll regions of two scrollable elements overlap.
     if (computedVertical) {
         const scrollTop = element.scrollTop;
-        if (computedVertical === 1 /* AutoScrollVerticalDirection.UP */) {
+        if (computedVertical === AutoScrollVerticalDirection.UP) {
             if (scrollTop > 0) {
-                verticalScrollDirection = 1 /* AutoScrollVerticalDirection.UP */;
+                verticalScrollDirection = AutoScrollVerticalDirection.UP;
             }
         }
         else if (element.scrollHeight - scrollTop > element.clientHeight) {
-            verticalScrollDirection = 2 /* AutoScrollVerticalDirection.DOWN */;
+            verticalScrollDirection = AutoScrollVerticalDirection.DOWN;
         }
     }
     if (computedHorizontal) {
         const scrollLeft = element.scrollLeft;
-        if (computedHorizontal === 1 /* AutoScrollHorizontalDirection.LEFT */) {
+        if (computedHorizontal === AutoScrollHorizontalDirection.LEFT) {
             if (scrollLeft > 0) {
-                horizontalScrollDirection = 1 /* AutoScrollHorizontalDirection.LEFT */;
+                horizontalScrollDirection = AutoScrollHorizontalDirection.LEFT;
             }
         }
         else if (element.scrollWidth - scrollLeft > element.clientWidth) {
-            horizontalScrollDirection = 2 /* AutoScrollHorizontalDirection.RIGHT */;
+            horizontalScrollDirection = AutoScrollHorizontalDirection.RIGHT;
         }
     }
     return [verticalScrollDirection, horizontalScrollDirection];