@jetbrains/ring-ui-built 8.0.0-beta.4 → 8.0.0-beta.5

package/components/internal/reorder-layout-context.js

@@ -0,0 +1,141 @@
+import { c } from 'react/compiler-runtime';
+import { createContext, useRef } from 'react';
+
+const ReorderLayoutContext = /*#__PURE__*/createContext({
+  registerReorderItem: () => () => {},
+  getItemBounds: () => undefined,
+  getClosestInsertionPoint: () => undefined
+});
+function useReorderLayoutContextValue() {
+  const $ = c(5);
+  if ($[0] !== "51d04139cf14f94fc3f354b9f5fd1983ccf84891cbc7a0b51772db425d0c409c") {
+    for (let $i = 0; $i < 5; $i += 1) {
+      $[$i] = Symbol.for("react.memo_cache_sentinel");
+    }
+    $[0] = "51d04139cf14f94fc3f354b9f5fd1983ccf84891cbc7a0b51772db425d0c409c";
+  }
+  let t0;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const getBoundsByItemIndex = useRef(t0);
+  let t1;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = function registerReorderItem(index, getBounds) {
+      getBoundsByItemIndex.current[index] = getBounds;
+      return () => {
+        delete getBoundsByItemIndex.current[index];
+      };
+    };
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const registerReorderItem = t1;
+  let t2;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = function getItemBounds(index_0) {
+      const getBounds_0 = getBoundsByItemIndex.current[index_0];
+      return getBounds_0?.();
+    };
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const getItemBounds = t2;
+  let t3;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    const getClosestInsertionPoint = function getClosestInsertionPoint(clientOffset, canReorder) {
+      const candidates = getBoundsByItemIndex.current.map((getBounds_1, itemIndex) => ({
+        itemIndex,
+        getBounds: getBounds_1,
+        beforeAllowed: canReorder(itemIndex),
+        afterAllowed: canReorder(itemIndex + 1)
+      })).filter(_temp);
+      if (!candidates.length) {
+        return;
+      }
+      const closest = [];
+      const computeClosest = function computeClosest(i) {
+        if (!closest[i]) {
+          const {
+            getBounds: getBounds_2,
+            beforeAllowed: beforeAllowed_0,
+            afterAllowed: afterAllowed_0
+          } = candidates[i];
+          const {
+            start,
+            end
+          } = getBounds_2();
+          const beforeDist = Math.abs(clientOffset - start);
+          const afterDist = Math.abs(clientOffset - end);
+          if (!afterAllowed_0) {
+            closest[i] = {
+              distance: beforeDist,
+              after: false
+            };
+          } else {
+            if (!beforeAllowed_0) {
+              closest[i] = {
+                distance: afterDist,
+                after: true
+              };
+            } else {
+              const after = afterDist < beforeDist;
+              closest[i] = {
+                distance: after ? afterDist : beforeDist,
+                after
+              };
+            }
+          }
+        }
+        return closest[i];
+      };
+      let l = 0;
+      let r = candidates.length - 1;
+      while (l < r) {
+        const m = Math.floor((l + r) / 2);
+        const {
+          distance
+        } = computeClosest(m);
+        if (l <= m - 1 && computeClosest(m - 1).distance < distance) {
+          r = m - 1;
+        } else {
+          if (m + 1 <= r && computeClosest(m + 1).distance < distance) {
+            l = m + 1;
+          } else {
+            return {
+              itemIndex: candidates[m].itemIndex,
+              after: computeClosest(m).after
+            };
+          }
+        }
+      }
+      return {
+        itemIndex: candidates[l].itemIndex,
+        after: computeClosest(l).after
+      };
+    };
+    t3 = {
+      registerReorderItem,
+      getItemBounds,
+      getClosestInsertionPoint
+    };
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+function _temp(t0) {
+  const {
+    beforeAllowed,
+    afterAllowed
+  } = t0;
+  return beforeAllowed || afterAllowed;
+}
+
+export { ReorderLayoutContext, useReorderLayoutContextValue };