@dnd-kit/collision 0.0.1

package/dist/index.cjs

@@ -0,0 +1,162 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  closestCenter: () => closestCenter,
+  defaultCollisionDetection: () => defaultCollisionDetection,
+  directionBiased: () => directionBiased,
+  pointerDistance: () => pointerDistance,
+  pointerIntersection: () => pointerIntersection,
+  shapeIntersection: () => shapeIntersection
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/algorithms/pointerIntersection.ts
+var import_abstract = require("@dnd-kit/abstract");
+var import_geometry = require("@dnd-kit/geometry");
+var pointerIntersection = ({ dragOperation, droppable }) => {
+  const pointerCoordinates = dragOperation.position.current;
+  if (!pointerCoordinates) {
+    return null;
+  }
+  const { id } = droppable;
+  if (!droppable.shape) {
+    return null;
+  }
+  if (droppable.shape.containsPoint(pointerCoordinates)) {
+    const distance = import_geometry.Point.distance(droppable.shape.center, pointerCoordinates);
+    return {
+      id,
+      value: 1 / distance,
+      priority: import_abstract.CollisionPriority.High
+    };
+  }
+  return null;
+};
+
+// src/algorithms/shapeIntersection.ts
+var import_abstract2 = require("@dnd-kit/abstract");
+var import_geometry2 = require("@dnd-kit/geometry");
+var shapeIntersection = ({
+  dragOperation,
+  droppable
+}) => {
+  if (!droppable.shape) {
+    return null;
+  }
+  const { shape } = dragOperation;
+  const intersectionArea = shape == null ? void 0 : shape.current.intersectionArea(droppable.shape);
+  if (intersectionArea) {
+    const { position } = dragOperation;
+    const distance = import_geometry2.Point.distance(droppable.shape.center, position.current);
+    const value = 1 / distance;
+    return {
+      id: droppable.id,
+      value,
+      priority: import_abstract2.CollisionPriority.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/default.ts
+var defaultCollisionDetection = (args) => {
+  var _a;
+  return (_a = pointerIntersection(args)) != null ? _a : shapeIntersection(args);
+};
+
+// src/algorithms/closestCenter.ts
+var import_abstract3 = require("@dnd-kit/abstract");
+var import_geometry3 = require("@dnd-kit/geometry");
+var closestCenter = (input) => {
+  var _a;
+  const { dragOperation, droppable } = input;
+  const { shape, position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const distance = import_geometry3.Point.distance(
+    droppable.shape.center,
+    (_a = shape == null ? void 0 : shape.current.center) != null ? _a : position.current
+  );
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    priority: import_abstract3.CollisionPriority.Low
+  };
+};
+
+// src/algorithms/directionBiased.ts
+var import_abstract4 = require("@dnd-kit/abstract");
+var import_geometry4 = require("@dnd-kit/geometry");
+var directionBiased = ({
+  dragOperation,
+  droppable
+}) => {
+  if (!droppable.shape) {
+    return null;
+  }
+  const { position, shape } = dragOperation;
+  const { direction } = position;
+  if (!shape) {
+    return null;
+  }
+  if (direction === null) {
+    return defaultCollisionDetection({ dragOperation, droppable });
+  }
+  const { center, boundingRectangle } = shape.current;
+  if (direction === "down" && boundingRectangle.bottom >= droppable.shape.center.y || direction === "up" && boundingRectangle.top <= droppable.shape.center.y || direction === "left" && boundingRectangle.left <= droppable.shape.center.x || direction === "right" && boundingRectangle.right >= droppable.shape.center.x) {
+    return {
+      id: droppable.id,
+      value: 1 / import_geometry4.Point.distance(droppable.shape.center, center),
+      priority: import_abstract4.CollisionPriority.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/pointerDistance.ts
+var import_abstract5 = require("@dnd-kit/abstract");
+var import_geometry5 = require("@dnd-kit/geometry");
+var pointerDistance = (input) => {
+  const { dragOperation, droppable } = input;
+  const { position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const distance = import_geometry5.Point.distance(droppable.shape.center, position.current);
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    priority: import_abstract5.CollisionPriority.Low
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  closestCenter,
+  defaultCollisionDetection,
+  directionBiased,
+  pointerDistance,
+  pointerIntersection,
+  shapeIntersection
+});

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { CollisionDetector } from '@dnd-kit/abstract';
+export { CollisionDetector } from '@dnd-kit/abstract';
+
+/**
+ * Returns the droppable that has the greatest intersection area with the
+ * pointer coordinates. If there are no pointer coordinates, or the pointer
+ * is not intersecting with any droppable, return the greatest intersection area
+ * between the collision shape and other intersecting droppable shapes.
+ */
+declare const defaultCollisionDetection: CollisionDetector;
+
+/**
+ * Returns the distance between the droppable shape and the drag operation shape.
+ */
+declare const closestCenter: CollisionDetector;
+
+/**
+ * A high precision collision detection algorithm that detects
+ * whether the pointer intersects with a given droppable element.
+ *
+ * Returns the distance between the pointer coordinates and the center of the
+ * droppable element if the pointer is within the droppable element.
+ *
+ * Returns null if the pointer is outside of the droppable element.
+ */
+declare const pointerIntersection: CollisionDetector;
+
+/**
+ * Returns the droppable with the greatest intersection area with
+ * the collision shape.
+ */
+declare const shapeIntersection: CollisionDetector;
+
+declare const directionBiased: CollisionDetector;
+
+/**
+ * Returns the distance between the droppable shape and the drag operation coordinates.
+ */
+declare const pointerDistance: CollisionDetector;
+
+export { closestCenter, defaultCollisionDetection, directionBiased, pointerDistance, pointerIntersection, shapeIntersection };

package/dist/index.js

@@ -0,0 +1,130 @@
+// src/algorithms/pointerIntersection.ts
+import { CollisionPriority } from "@dnd-kit/abstract";
+import { Point } from "@dnd-kit/geometry";
+var pointerIntersection = ({ dragOperation, droppable }) => {
+  const pointerCoordinates = dragOperation.position.current;
+  if (!pointerCoordinates) {
+    return null;
+  }
+  const { id } = droppable;
+  if (!droppable.shape) {
+    return null;
+  }
+  if (droppable.shape.containsPoint(pointerCoordinates)) {
+    const distance = Point.distance(droppable.shape.center, pointerCoordinates);
+    return {
+      id,
+      value: 1 / distance,
+      priority: CollisionPriority.High
+    };
+  }
+  return null;
+};
+
+// src/algorithms/shapeIntersection.ts
+import { CollisionPriority as CollisionPriority2 } from "@dnd-kit/abstract";
+import { Point as Point2 } from "@dnd-kit/geometry";
+var shapeIntersection = ({
+  dragOperation,
+  droppable
+}) => {
+  if (!droppable.shape) {
+    return null;
+  }
+  const { shape } = dragOperation;
+  const intersectionArea = shape == null ? void 0 : shape.current.intersectionArea(droppable.shape);
+  if (intersectionArea) {
+    const { position } = dragOperation;
+    const distance = Point2.distance(droppable.shape.center, position.current);
+    const value = 1 / distance;
+    return {
+      id: droppable.id,
+      value,
+      priority: CollisionPriority2.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/default.ts
+var defaultCollisionDetection = (args) => {
+  var _a;
+  return (_a = pointerIntersection(args)) != null ? _a : shapeIntersection(args);
+};
+
+// src/algorithms/closestCenter.ts
+import { CollisionPriority as CollisionPriority3 } from "@dnd-kit/abstract";
+import { Point as Point3 } from "@dnd-kit/geometry";
+var closestCenter = (input) => {
+  var _a;
+  const { dragOperation, droppable } = input;
+  const { shape, position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const distance = Point3.distance(
+    droppable.shape.center,
+    (_a = shape == null ? void 0 : shape.current.center) != null ? _a : position.current
+  );
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    priority: CollisionPriority3.Low
+  };
+};
+
+// src/algorithms/directionBiased.ts
+import { CollisionPriority as CollisionPriority4 } from "@dnd-kit/abstract";
+import { Point as Point4 } from "@dnd-kit/geometry";
+var directionBiased = ({
+  dragOperation,
+  droppable
+}) => {
+  if (!droppable.shape) {
+    return null;
+  }
+  const { position, shape } = dragOperation;
+  const { direction } = position;
+  if (!shape) {
+    return null;
+  }
+  if (direction === null) {
+    return defaultCollisionDetection({ dragOperation, droppable });
+  }
+  const { center, boundingRectangle } = shape.current;
+  if (direction === "down" && boundingRectangle.bottom >= droppable.shape.center.y || direction === "up" && boundingRectangle.top <= droppable.shape.center.y || direction === "left" && boundingRectangle.left <= droppable.shape.center.x || direction === "right" && boundingRectangle.right >= droppable.shape.center.x) {
+    return {
+      id: droppable.id,
+      value: 1 / Point4.distance(droppable.shape.center, center),
+      priority: CollisionPriority4.Normal
+    };
+  }
+  return null;
+};
+
+// src/algorithms/pointerDistance.ts
+import { CollisionPriority as CollisionPriority5 } from "@dnd-kit/abstract";
+import { Point as Point5 } from "@dnd-kit/geometry";
+var pointerDistance = (input) => {
+  const { dragOperation, droppable } = input;
+  const { position } = dragOperation;
+  if (!droppable.shape) {
+    return null;
+  }
+  const distance = Point5.distance(droppable.shape.center, position.current);
+  const value = 1 / distance;
+  return {
+    id: droppable.id,
+    value,
+    priority: CollisionPriority5.Low
+  };
+};
+export {
+  closestCenter,
+  defaultCollisionDetection,
+  directionBiased,
+  pointerDistance,
+  pointerIntersection,
+  shapeIntersection
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@dnd-kit/collision",
+  "type": "module",
+  "version": "0.0.1",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts --external react",
+    "lint": "TIMING=1 eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "dependencies": {
+    "@dnd-kit/abstract": "*",
+    "@dnd-kit/geometry": "*",
+    "tslib": "^2.6.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.9",
+    "@types/react-dom": "^18.0.4",
+    "eslint": "^8.38.0",
+    "@dnd-kit/eslint-config": "*",
+    "react": "^18.1.0",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}