@dnd-kit/dom 0.5.2-beta-20261029020134 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnd-kit/dom",
-  "version": "0.5.2-beta-20261029020134",
+  "version": "0.5.2",
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
@@ -75,10 +75,10 @@
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
   },
   "dependencies": {
-    "@dnd-kit/abstract": "0.5.2-beta-20261029020134",
-    "@dnd-kit/collision": "0.5.2-beta-20261029020134",
-    "@dnd-kit/geometry": "0.5.2-beta-20261029020134",
-    "@dnd-kit/state": "0.5.2-beta-20261029020134",
+    "@dnd-kit/abstract": "^0.5.2",
+    "@dnd-kit/collision": "^0.5.2",
+    "@dnd-kit/geometry": "^0.5.2",
+    "@dnd-kit/state": "^0.5.2",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/utilities.cjs

@@ -749,6 +749,60 @@ function hidePopover(element) {
   }
 }
 
+// src/utilities/scheduling/scheduler.ts
+var Scheduler = class {
+  constructor(scheduler4) {
+    this.scheduler = scheduler4;
+    this.pending = false;
+    this.tasks = /* @__PURE__ */ new Set();
+    this.resolvers = /* @__PURE__ */ new Set();
+    this.flush = () => {
+      const { tasks, resolvers } = this;
+      this.pending = false;
+      this.tasks = /* @__PURE__ */ new Set();
+      this.resolvers = /* @__PURE__ */ new Set();
+      for (const task of tasks) {
+        task();
+      }
+      for (const resolve of resolvers) {
+        resolve();
+      }
+    };
+  }
+  schedule(task) {
+    this.tasks.add(task);
+    if (!this.pending) {
+      this.pending = true;
+      this.scheduler(this.flush);
+    }
+    return new Promise((resolve) => this.resolvers.add(resolve));
+  }
+};
+var scheduler = new Scheduler((callback) => {
+  if (typeof requestAnimationFrame === "function") {
+    requestAnimationFrame(callback);
+  } else {
+    callback();
+  }
+});
+
+// src/utilities/styles/getComputedStyles.ts
+var scheduler2 = new Scheduler((callback) => setTimeout(callback, 50));
+var cachedStyles = /* @__PURE__ */ new Map();
+var clear = cachedStyles.clear.bind(cachedStyles);
+function getComputedStyles(element, cached = false) {
+  if (!cached) return computeStyles(element);
+  let styles = cachedStyles.get(element);
+  if (styles) return styles;
+  styles = computeStyles(element);
+  cachedStyles.set(element, styles);
+  scheduler2.schedule(clear);
+  return styles;
+}
+function computeStyles(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+
 // src/utilities/scroll/documentScrollingElement.ts
 function isDocumentScrollingElement(element) {
   if (!canUseDOM || !element) {
@@ -761,27 +815,35 @@ function isDocumentScrollingElement(element) {
 function getScrollPosition(scrollableElement) {
   var _a, _b;
   const window2 = getWindow(scrollableElement);
-  const rect = isDocumentScrollingElement(scrollableElement) ? getViewportBoundingRectangle(scrollableElement) : getBoundingRectangle(scrollableElement);
+  const isDocument2 = isDocumentScrollingElement(scrollableElement);
+  const rect = isDocument2 ? getViewportBoundingRectangle(scrollableElement) : getBoundingRectangle(scrollableElement);
   const vv = window2.visualViewport;
-  const dimensions = isDocumentScrollingElement(scrollableElement) ? {
+  const dimensions = isDocument2 ? {
     height: (_a = vv == null ? void 0 : vv.height) != null ? _a : window2.innerHeight,
     width: (_b = vv == null ? void 0 : vv.width) != null ? _b : window2.innerWidth
   } : {
     height: scrollableElement.clientHeight,
     width: scrollableElement.clientWidth
   };
+  const rangeX = scrollableElement.scrollWidth - dimensions.width;
+  const styles = getComputedStyles(scrollableElement, true);
+  const hasNegativeScrollLeft = isDocument2 ? styles.direction === "rtl" : isHorizontalScrollReversed(styles);
   const position = {
     current: {
       x: scrollableElement.scrollLeft,
       y: scrollableElement.scrollTop
     },
+    min: {
+      x: hasNegativeScrollLeft ? -rangeX : 0,
+      y: 0
+    },
     max: {
-      x: scrollableElement.scrollWidth - dimensions.width,
+      x: hasNegativeScrollLeft ? 0 : rangeX,
       y: scrollableElement.scrollHeight - dimensions.height
     }
   };
-  const isTop = position.current.y <= 0;
-  const isLeft = position.current.x <= 0;
+  const isTop = position.current.y <= position.min.y;
+  const isLeft = position.current.x <= position.min.x;
   const isBottom = position.current.y >= position.max.y;
   const isRight = position.current.x >= position.max.x;
   return {
@@ -793,14 +855,27 @@ function getScrollPosition(scrollableElement) {
     isRight
   };
 }
+function isHorizontalScrollReversed(styles) {
+  const { direction, display, writingMode } = styles;
+  const isVertical = writingMode === "vertical-lr" || writingMode === "vertical-rl" || writingMode === "sideways-lr" || writingMode === "sideways-rl";
+  const isReversed = isVertical ? writingMode === "vertical-rl" || writingMode === "sideways-rl" : direction === "rtl";
+  if (display !== "flex" && display !== "inline-flex") {
+    return isReversed;
+  }
+  const { flexDirection, flexWrap } = styles;
+  const isRow = flexDirection === "row" || flexDirection === "row-reverse";
+  const isHorizontalMainAxis = isVertical ? !isRow : isRow;
+  const isFlexReversed = isHorizontalMainAxis ? flexDirection === "row-reverse" || flexDirection === "column-reverse" : flexWrap === "wrap-reverse";
+  return isReversed !== isFlexReversed;
+}
 
 // src/utilities/scroll/canScroll.ts
 function canScroll(scrollableElement, by, scrollPosition = getScrollPosition(scrollableElement)) {
   const { isTop, isBottom, isLeft, isRight, position } = scrollPosition;
   const { x, y } = by != null ? by : { x: 0, y: 0 };
-  const top = !isTop && position.current.y + y > 0;
+  const top = !isTop && position.current.y + y > position.min.y;
   const bottom = !isBottom && position.current.y + y < position.max.y;
-  const left = !isLeft && position.current.x + x > 0;
+  const left = !isLeft && position.current.x + x > position.min.x;
   const right = !isRight && position.current.x + x < position.max.x;
   return {
     top,
@@ -812,60 +887,6 @@ function canScroll(scrollableElement, by, scrollPosition = getScrollPosition(scr
   };
 }
 
-// src/utilities/scheduling/scheduler.ts
-var Scheduler = class {
-  constructor(scheduler4) {
-    this.scheduler = scheduler4;
-    this.pending = false;
-    this.tasks = /* @__PURE__ */ new Set();
-    this.resolvers = /* @__PURE__ */ new Set();
-    this.flush = () => {
-      const { tasks, resolvers } = this;
-      this.pending = false;
-      this.tasks = /* @__PURE__ */ new Set();
-      this.resolvers = /* @__PURE__ */ new Set();
-      for (const task of tasks) {
-        task();
-      }
-      for (const resolve of resolvers) {
-        resolve();
-      }
-    };
-  }
-  schedule(task) {
-    this.tasks.add(task);
-    if (!this.pending) {
-      this.pending = true;
-      this.scheduler(this.flush);
-    }
-    return new Promise((resolve) => this.resolvers.add(resolve));
-  }
-};
-var scheduler = new Scheduler((callback) => {
-  if (typeof requestAnimationFrame === "function") {
-    requestAnimationFrame(callback);
-  } else {
-    callback();
-  }
-});
-
-// src/utilities/styles/getComputedStyles.ts
-var scheduler2 = new Scheduler((callback) => setTimeout(callback, 50));
-var cachedStyles = /* @__PURE__ */ new Map();
-var clear = cachedStyles.clear.bind(cachedStyles);
-function getComputedStyles(element, cached = false) {
-  if (!cached) return computeStyles(element);
-  let styles = cachedStyles.get(element);
-  if (styles) return styles;
-  styles = computeStyles(element);
-  cachedStyles.set(element, styles);
-  scheduler2.schedule(clear);
-  return styles;
-}
-function computeStyles(element) {
-  return getWindow(element).getComputedStyle(element);
-}
-
 // src/utilities/scroll/isFixed.ts
 function isFixed(node, computedStyle = getComputedStyles(node, true)) {
   return computedStyle.position === "fixed" || computedStyle.position === "sticky";