@worktile/gantt 15.1.0-next.1 → 15.1.0-next.11

package/esm2020/utils/drag-scroll.mjs

@@ -0,0 +1,54 @@
+/**
+ * Proximity, as a ratio to width/height at which to start auto-scrolling the drop list or the
+ * viewport. The value comes from trying it out manually until it feels right.
+ */
+const SCROLL_PROXIMITY_THRESHOLD = 0.05;
+/**
+ * Gets whether the horizontal auto-scroll direction of a node.
+ * @param clientRect Dimensions of the node.
+ * @param pointerX Position of the user's pointer along the x axis.
+ */
+export 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 */;
+    }
+    else if (pointerX >= right - xThreshold && pointerX <= right + xThreshold) {
+        return 2 /* AutoScrollHorizontalDirection.RIGHT */;
+    }
+    return 0 /* AutoScrollHorizontalDirection.NONE */;
+}
+/**
+ * Checks whether the pointer coordinates are close to a ClientRect.
+ * @param rect ClientRect to check against.
+ * @param threshold Threshold around the ClientRect.
+ * @param pointerX Coordinates along the X axis.
+ * @param pointerY Coordinates along the Y axis.
+ */
+export function isPointerNearClientRect(rect, threshold, pointerX, pointerY) {
+    const { top, right, bottom, left, width, height } = rect;
+    const xThreshold = width * threshold;
+    const yThreshold = height * threshold;
+    return pointerY > top - yThreshold && pointerY < bottom + yThreshold && pointerX > left - xThreshold && pointerX < right + xThreshold;
+}
+/**
+ * Gets the speed rate of auto scrolling
+ * @param clientRect Dimensions of the node.
+ * @param pointerX Position of the user's pointer along the x axis.
+ * @param horizontalScrollDirection The direction in which the mouse is dragged horizontally
+ */
+export function getAutoScrollSpeedRates(clientRect, pointerX, horizontalScrollDirection) {
+    let autoScrollSpeedRates = 4;
+    const speedLevels = 4;
+    const { left, right, width } = clientRect;
+    const xThreshold = width * SCROLL_PROXIMITY_THRESHOLD;
+    if (horizontalScrollDirection === 1 /* AutoScrollHorizontalDirection.LEFT */) {
+        autoScrollSpeedRates = Math.ceil((xThreshold - (pointerX > left ? pointerX - left : 0)) / (xThreshold / speedLevels));
+    }
+    if (horizontalScrollDirection === 2 /* AutoScrollHorizontalDirection.RIGHT */) {
+        autoScrollSpeedRates = Math.ceil((xThreshold - (right > pointerX ? right - pointerX : 0)) / (xThreshold / speedLevels));
+    }
+    return autoScrollSpeedRates;
+}
+//# sourceMappingURL=data:application/json;base64,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