@marsio/vue-draggable 1.0.2 → 1.0.3

package/build/cjs/utils/domFns.js

@@ -3,43 +3,47 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.addClassName = addClassName;
-exports.addEvent = addEvent;
-exports.addUserSelectStyles = addUserSelectStyles;
-exports.createCSSTransform = createCSSTransform;
-exports.createSVGTransform = createSVGTransform;
-exports.getTouch = getTouch;
-exports.getTouchIdentifier = getTouchIdentifier;
-exports.getTranslation = getTranslation;
-exports.innerHeight = innerHeight;
-exports.innerWidth = innerWidth;
-exports.matchesSelector = matchesSelector;
-exports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
-exports.offsetXYFromParent = offsetXYFromParent;
-exports.outerHeight = outerHeight;
-exports.outerWidth = outerWidth;
-exports.removeClassName = removeClassName;
-exports.removeEvent = removeEvent;
-exports.removeUserSelectStyles = removeUserSelectStyles;
+exports.removeUserSelectStyles = exports.removeEvent = exports.removeClassName = exports.outerWidth = exports.outerHeight = exports.offsetXYFromParent = exports.matchesSelectorAndParentsTo = exports.matchesSelector = exports.innerWidth = exports.innerHeight = exports.getTranslation = exports.getTouchIdentifier = exports.getTouch = exports.createSVGTransform = exports.createCSSTransform = exports.addUserSelectStyles = exports.addEvent = exports.addClassName = void 0;
 var _getPrefix = _interopRequireWildcard(require("./getPrefix"));
 var _shims = require("./shims");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Provides utility functions for DOM manipulation and event handling.
+ */
+
+/**
+ * Cached method name for matchesSelector.
+ */
 let matchesSelectorFunc = '';
-function matchesSelector(el, selector) {
+
+/**
+ * Checks if the element matches the given CSS selector.
+ * 
+ * @param el - The element to check.
+ * @param selector - The CSS selector to match against.
+ * @returns True if the element matches the selector, false otherwise.
+ */
+const matchesSelector = (el, selector) => {
   if (!matchesSelectorFunc) {
     matchesSelectorFunc = (0, _shims.findInArray)(['matches', 'webkitMatchesSelector', 'mozMatchesSelector', 'msMatchesSelector', 'oMatchesSelector'], function (method) {
       return (0, _shims.isFunction)(el[method]);
     });
   }
-
-  // Might not be found entirely (not an Element?) - in that case, bail
   if (!(0, _shims.isFunction)(el[matchesSelectorFunc])) return false;
   return el[matchesSelectorFunc](selector);
-}
+};
 
-// Works up the tree to the draggable itself attempting to match selector.
-function matchesSelectorAndParentsTo(el, selector, baseNode) {
+/**
+ * Checks if the element or any of its parents match the given CSS selector.
+ * 
+ * @param el - The element to start the search from.
+ * @param selector - The CSS selector to match against.
+ * @param baseNode - The base node to stop the search at.
+ * @returns True if a match is found, false otherwise.
+ */
+exports.matchesSelector = matchesSelector;
+const matchesSelectorAndParentsTo = (el, selector, baseNode) => {
   let node = el;
   do {
     if (matchesSelector(node, selector)) return true;
@@ -47,8 +51,18 @@ function matchesSelectorAndParentsTo(el, selector, baseNode) {
     node = node.parentNode;
   } while (node);
   return false;
-}
-function addEvent(el, event, handler, inputOptions) {
+};
+
+/**
+ * Adds an event listener to an element.
+ * 
+ * @param el - The element to add the event listener to.
+ * @param event - The event type to listen for.
+ * @param handler - The function to call when the event occurs.
+ * @param inputOptions - Optional parameters for the event listener.
+ */
+exports.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
+const addEvent = (el, event, handler, inputOptions) => {
   if (!el) return;
   const options = {
     capture: true,
@@ -61,8 +75,18 @@ function addEvent(el, event, handler, inputOptions) {
   } else {
     el[`on${event}`] = handler;
   }
-}
-function removeEvent(el, event, handler, inputOptions) {
+};
+
+/**
+ * Removes an event listener from an element.
+ * 
+ * @param el - The element to remove the event listener from.
+ * @param event - The event type of the listener to remove.
+ * @param handler - The function that was called when the event occurred.
+ * @param inputOptions - Optional parameters for the event listener.
+ */
+exports.addEvent = addEvent;
+const removeEvent = (el, event, handler, inputOptions) => {
   if (!el) return;
   const options = {
     capture: true,
@@ -71,46 +95,82 @@ function removeEvent(el, event, handler, inputOptions) {
   if (el.removeEventListener) {
     el.removeEventListener(event, handler, options);
   } else if (el.detachEvent) {
-    el.detachEvent('on' + event, handler);
+    el.detachEvent?.('on' + event, handler);
   } else {
     el[`on${event}`] = null;
   }
-}
-function outerHeight(node) {
-  // This is deliberately excluding margin for our calculations, since we are using
-  // offsetTop which is including margin. See getBoundPosition
+};
+
+/**
+ * Calculates the outer height of an element, including padding and border.
+ * 
+ * @param node - The element to calculate the outer height of.
+ * @returns The outer height of the element.
+ */
+exports.removeEvent = removeEvent;
+const outerHeight = node => {
   let height = node.clientHeight;
   const computedStyle = node.ownerDocument.defaultView?.getComputedStyle(node);
   height += (0, _shims.int)(computedStyle.borderTopWidth);
   height += (0, _shims.int)(computedStyle.borderBottomWidth);
   return height;
-}
-function outerWidth(node) {
-  // This is deliberately excluding margin for our calculations, since we are using
-  // offsetLeft which is including margin. See getBoundPosition
+};
+
+/**
+ * Calculates the outer width of an element, including padding and border.
+ * 
+ * @param node - The element to calculate the outer width of.
+ * @returns The outer width of the element.
+ */
+exports.outerHeight = outerHeight;
+const outerWidth = node => {
   let width = node.clientWidth;
   const computedStyle = node.ownerDocument?.defaultView?.getComputedStyle(node);
   width += (0, _shims.int)(computedStyle.borderLeftWidth);
   width += (0, _shims.int)(computedStyle.borderRightWidth);
   return width;
-}
-function innerHeight(node) {
+};
+
+/**
+ * Calculates the inner height of an element, excluding padding.
+ * 
+ * @param node - The element to calculate the inner height of.
+ * @returns The inner height of the element.
+ */
+exports.outerWidth = outerWidth;
+const innerHeight = node => {
   let height = node.clientHeight;
   const computedStyle = node.ownerDocument?.defaultView?.getComputedStyle(node);
   height -= (0, _shims.int)(computedStyle.paddingTop);
   height -= (0, _shims.int)(computedStyle.paddingBottom);
   return height;
-}
-function innerWidth(node) {
+};
+
+/**
+ * Calculates the inner width of an element, excluding padding.
+ * 
+ * @param node - The element to calculate the inner width of.
+ * @returns The inner width of the element.
+ */
+exports.innerHeight = innerHeight;
+const innerWidth = node => {
   let width = node.clientWidth;
   const computedStyle = node.ownerDocument?.defaultView?.getComputedStyle(node);
   width -= (0, _shims.int)(computedStyle.paddingLeft);
   width -= (0, _shims.int)(computedStyle.paddingRight);
   return width;
-}
+};
 
-// Get from offsetParent
-function offsetXYFromParent(evt, offsetParent, scale) {
+/**
+ * Calculates the X and Y offset of an event from the parent element.
+ * 
+ * @param evt - The event object.
+ * @param offsetParent - The parent element to calculate the offset from.
+ * @param scale - The scale factor to apply to the offset.
+ * @returns The X and Y offset from the parent element.
+ */
+exports.innerWidth = innerWidth;
+const offsetXYFromParent = (evt, offsetParent, scale) => {
   const isBody = offsetParent === offsetParent.ownerDocument.body;
   const offsetParentRect = isBody ? {
     left: 0,
@@ -122,18 +182,18 @@ function offsetXYFromParent(evt, offsetParent, scale) {
     x,
     y
   };
-}
-function createCSSTransform(controlPos, positionOffset) {
-  const translation = getTranslation(controlPos, positionOffset, 'px');
-  return {
-    [(0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default)]: translation
-  };
-}
-function createSVGTransform(controlPos, positionOffset) {
-  const translation = getTranslation(controlPos, positionOffset, '');
-  return translation;
-}
-function getTranslation(_ref, positionOffset, unitSuffix) {
+};
+
+/**
+ * Generates a CSS transform string from a position and offset.
+ * 
+ * @param controlPos - The position of the control.
+ * @param positionOffset - The offset to apply to the position.
+ * @param unitSuffix - The unit to use for the position values.
+ * @returns A CSS transform string.
+ */
+exports.offsetXYFromParent = offsetXYFromParent;
+const getTranslation = (_ref, positionOffset, unitSuffix) => {
   let {
     x,
     y
@@ -145,22 +205,100 @@ function getTranslation(_ref, positionOffset, unitSuffix) {
     translation = `translate(${defaultX}, ${defaultY})` + translation;
   }
   return translation;
-}
-function getTouch(e, identifier) {
+};
+
+/**
+ * Creates a CSS transform property for a given position and offset.
+ * 
+ * @param controlPos - The control position.
+ * @param positionOffset - The position offset.
+ * @returns An object with a single property for CSS transform.
+ */
+exports.getTranslation = getTranslation;
+const createCSSTransform = (controlPos, positionOffset) => {
+  const translation = getTranslation(controlPos, positionOffset, 'px');
+  return {
+    [(0, _getPrefix.browserPrefixToKey)('transform', _getPrefix.default)]: translation
+  };
+};
+
+/**
+ * Creates an SVG transform attribute value for a given position and offset.
+ * 
+ * @param controlPos - The control position.
+ * @param positionOffset - The position offset.
+ * @returns A string for the SVG transform attribute.
+ */
+exports.createCSSTransform = createCSSTransform;
+const createSVGTransform = (controlPos, positionOffset) => {
+  const translation = getTranslation(controlPos, positionOffset, '');
+  return translation;
+};
+
+/**
+ * Retrieves the touch object with a specific identifier from an event.
+ * 
+ * @param e - The event object.
+ * @param identifier - The identifier of the touch object to retrieve.
+ * @returns The touch object, or null if not found.
+ */
+exports.createSVGTransform = createSVGTransform;
+const getTouch = (e, identifier) => {
   return e.targetTouches && (0, _shims.findInArray)(e.targetTouches, t => identifier === t.identifier) || e.changedTouches && (0, _shims.findInArray)(e.changedTouches, t => identifier === t.identifier);
-}
-function getTouchIdentifier(e) {
+};
+
+/**
+ * Retrieves the identifier of the first touch point from an event.
+ * 
+ * @param e - The event object.
+ * @returns The identifier of the first touch point, or null if not available.
+ */
+exports.getTouch = getTouch;
+const getTouchIdentifier = e => {
   if (e.targetTouches && e.targetTouches[0]) return e.targetTouches[0].identifier;
   if (e.changedTouches && e.changedTouches[0]) return e.changedTouches[0].identifier;
-  return;
-}
+  return null;
+};
 
-// User-select Hacks:
-//
-// Useful for preventing blue highlights all over everything when dragging.
+/**
+ * Adds a class name to an element.
+ * 
+ * @param el - The element to add the class name to.
+ * @param className - The class name to add.
+ */
+exports.getTouchIdentifier = getTouchIdentifier;
+const addClassName = (el, className) => {
+  if (el.classList) {
+    el.classList.add(className);
+  } else {
+    if (!el.className.match(new RegExp(`(?:^|\\s)${className}(?!\\S)`))) {
+      el.className += ` ${className}`;
+    }
+  }
+};
 
-// Note we're passing `document` b/c we could be iframed
-function addUserSelectStyles(doc) {
+/**
+ * Removes a class name from an element.
+ * 
+ * @param el - The element to remove the class name from.
+ * @param className - The class name to remove.
+ */
+exports.addClassName = addClassName;
+const removeClassName = (el, className) => {
+  if (el.classList) {
+    el.classList.remove(className);
+  } else {
+    el.className = el.className.replace(new RegExp(`(?:^|\\s)${className}(?!\\S)`, 'g'), '');
+  }
+};
+
+/**
+ * Adds styles to prevent user selection during drag operations.
+ * 
+ * @param doc - The document to add the styles to. Optional.
+ */
+exports.removeClassName = removeClassName;
+const addUserSelectStyles = doc => {
   if (!doc) return;
   let styleEl = doc.getElementById('vue-draggable-style-el');
   if (!styleEl) {
@@ -172,38 +310,24 @@ function addUserSelectStyles(doc) {
     doc.getElementsByTagName('head')[0].appendChild(styleEl);
   }
   if (doc.body) addClassName(doc.body, 'vue-draggable-transparent-selection');
-}
-function removeUserSelectStyles(doc) {
+};
+
+/**
+ * Removes styles added to prevent user selection during drag operations.
+ * 
+ * @param doc - The document to remove the styles from. Optional.
+ */
+exports.addUserSelectStyles = addUserSelectStyles;
+const removeUserSelectStyles = doc => {
   if (!doc) return;
   try {
     if (doc.body) removeClassName(doc.body, 'vue-draggable-transparent-selection');
-    if (doc.selection) {
-      doc.selection.empty();
-    } else {
-      // Remove selection caused by scroll, unless it's a focused input
-      // (we use doc.defaultView in case we're in an iframe)
-      const selection = (doc.defaultView || window).getSelection();
-      if (selection && selection.type !== 'Caret') {
-        selection.removeAllRanges();
-      }
+    const selection = doc.getSelection();
+    if (selection && selection.type !== 'Caret') {
+      selection.removeAllRanges();
     }
   } catch (e) {
-    // probably IE
-  }
-}
-function addClassName(el, className) {
-  if (el.classList) {
-    el.classList.add(className);
-  } else {
-    if (!el.className.match(new RegExp(`(?:^|\\s)${className}(?!\\S)`))) {
-      el.className += ` ${className}`;
-    }
-  }
-}
-function removeClassName(el, className) {
-  if (el.classList) {
-    el.classList.remove(className);
-  } else {
-    el.className = el.className.replace(new RegExp(`(?:^|\\s)${className}(?!\\S)`, 'g'), '');
+    console.error(e);
   }
-}
+};
+exports.removeUserSelectStyles = removeUserSelectStyles;

package/build/cjs/utils/log.js

@@ -4,6 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = log;
-function log() {
-  // if (process.env.DRAGGABLE_DEBUG) console.log(...args);
-}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function log() {}

package/build/cjs/utils/positionFns.js

@@ -3,84 +3,115 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.canDragX = canDragX;
-exports.canDragY = canDragY;
-exports.createCoreData = createCoreData;
-exports.createDraggableData = createDraggableData;
-exports.getBoundPosition = getBoundPosition;
-exports.getControlPosition = getControlPosition;
-exports.snapToGrid = snapToGrid;
-var _get = _interopRequireDefault(require("lodash/get"));
+exports.snapToGrid = exports.getControlPosition = exports.getBoundPosition = exports.createDraggableData = exports.createCoreData = exports.canDragY = exports.canDragX = void 0;
 var _domFns = require("./domFns");
 var _shims = require("./shims");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function getBoundPosition(draggable, x, y) {
-  // If no bounds, short-circuit and move on
-  if (!draggable.props.bounds) return [x, y];
+// Quick clone for bounds. We're doing this because we don't want to mess with the original bounds object.
+// It's a simple copy, nothing fancy.
+const cloneBounds = bounds => {
+  return {
+    left: bounds.left,
+    top: bounds.top,
+    right: bounds.right,
+    bottom: bounds.bottom
+  };
+};
 
-  // Clone new bounds
+// This one's a bit tricky. We're trying to find the actual DOM node for a draggable component.
+// It's using some internal React stuff, so don't worry if it looks a bit weird.
+const findDOMNode = draggable => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return draggable.findDOMNode();
+};
+
+// Ever got annoyed by CSS values being strings? Yeah, me too. This function takes those strings and turns them into numbers.
+// Also, it warns you if something's not right, which is pretty handy.
+const parseStyleToInt = (style, property) => {
+  if (!(property in style)) {
+    console.warn(`Property "${String(property)}" does not exist on the provided style object.`);
+    return 0;
+  }
+  const value = style[property];
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    console.warn(`Value of property "${String(property)}" is not a valid number.`);
+    return 0;
+  }
+  return parsed;
+};
+
+// This is where the magic happens. We're making sure the draggable stays within its bounds.
+// It's a bit of math and some conditionals. Nothing too scary, but it does the job.
+const getBoundPosition = (draggable, x, y) => {
+  if (!draggable.props.bounds) return [x, y];
   let bounds = draggable.props.bounds;
   bounds = typeof bounds === 'string' ? bounds : cloneBounds(bounds);
   const node = findDOMNode(draggable);
+  if (!node) return [x, y];
   const {
     ownerDocument
   } = node;
-  const ownerWindow = (0, _get.default)(node, 'ownerWindow');
-  const defaultView = (0, _get.default)(node, 'ownerWindow.defaultView');
-  if (defaultView && typeof bounds === 'string') {
-    let boundNode;
-    if (bounds === 'parent') {
-      boundNode = node.parentNode;
-    } else {
-      boundNode = ownerDocument.querySelector(bounds);
-    }
+  const ownerWindow = ownerDocument?.defaultView;
+  if (!ownerWindow) {
+    return [x, y];
+  }
+  if (typeof bounds === 'string') {
+    const boundNode = bounds === 'parent' ? node.parentNode : ownerDocument.querySelector(bounds);
     if (!(boundNode instanceof ownerWindow.HTMLElement)) {
-      throw new Error(`Bounds selector ${bounds} could not find an element.`);
+      throw new Error(`Bounds selector "${bounds}" could not find an element.`);
     }
     const nodeStyle = ownerWindow.getComputedStyle(node);
     const boundNodeStyle = ownerWindow.getComputedStyle(boundNode);
-    // Compute bounds. This is a pain with padding and offsets but this gets it exactly right.
     bounds = {
-      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
-      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
-      right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
-      bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
+      left: -node.offsetLeft + parseStyleToInt(boundNodeStyle, 'paddingLeft') + parseStyleToInt(nodeStyle, 'marginLeft'),
+      top: -node.offsetTop + parseStyleToInt(boundNodeStyle, 'paddingTop') + parseStyleToInt(nodeStyle, 'marginTop'),
+      right: (0, _domFns.innerWidth)(boundNode) - (0, _domFns.outerWidth)(node) - node.offsetLeft + parseStyleToInt(boundNodeStyle, 'paddingRight') - parseStyleToInt(nodeStyle, 'marginRight'),
+      bottom: (0, _domFns.innerHeight)(boundNode) - (0, _domFns.outerHeight)(node) - node.offsetTop + parseStyleToInt(boundNodeStyle, 'paddingBottom') - parseStyleToInt(nodeStyle, 'marginBottom')
     };
   }
 
-  // Keep x and y below right and bottom limits...
-  if ((0, _shims.isNum)(bounds.right)) x = Math.min(x, bounds.right);
-  if ((0, _shims.isNum)(bounds.bottom)) y = Math.min(y, bounds.bottom);
-
-  // But above left and top limits.
-  if ((0, _shims.isNum)(bounds.left)) x = Math.max(x, bounds.left);
-  if ((0, _shims.isNum)(bounds.top)) y = Math.max(y, bounds.top);
+  // Clamp x and y to be within the bounds.
+  x = Math.max(Math.min(x, bounds.right || 0), bounds.left || 0);
+  y = Math.max(Math.min(y, bounds.bottom || 0), bounds.top || 0);
   return [x, y];
-}
-function snapToGrid(grid, pendingX, pendingY) {
+};
+
+// Snapping to a grid is super useful for aligning stuff. This function just rounds the position to the nearest grid point.
+exports.getBoundPosition = getBoundPosition;
+const snapToGrid = (grid, pendingX, pendingY) => {
   const x = Math.round(pendingX / grid[0]) * grid[0];
   const y = Math.round(pendingY / grid[1]) * grid[1];
   return [x, y];
-}
-function canDragX(draggable) {
+};
+
+// Can we drag along the x-axis? This checks the draggable's props to see what's allowed.
+exports.snapToGrid = snapToGrid;
+const canDragX = draggable => {
   return draggable.props.axis === 'both' || draggable.props.axis === 'x';
-}
-function canDragY(draggable) {
+};
+
+// Same as canDragX, but for the y-axis. Gotta keep things flexible.
+exports.canDragX = canDragX;
+const canDragY = draggable => {
   return draggable.props.axis === 'both' || draggable.props.axis === 'y';
-}
+};
 
-// Get {x, y} positions from event.
-function getControlPosition(e, draggableCore, touchIdentifier) {
+// Getting the control position is a bit of DOM manipulation and event handling.
+// It's a bit dense, but it's just calculating positions based on the event and the draggable's state.
+exports.canDragY = canDragY;
+const getControlPosition = (e, draggableCore, touchIdentifier) => {
   const touchObj = typeof touchIdentifier === 'number' ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
   if (typeof touchIdentifier === 'number' && !touchObj) return null; // not the right touch
   const node = findDOMNode(draggableCore);
   // User can provide an offsetParent if desired.
   const offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
   return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
-}
+};
 
-// Create an data object exposed by <DraggableCore>'s events
-function createCoreData(draggable, x, y) {
+// When you start dragging, or move the draggable, this function updates the state with the new position.
+// It's a bit of a state management thing, keeping track of deltas and positions.
+exports.getControlPosition = getControlPosition;
+const createCoreData = (draggable, x, y) => {
   const state = draggable.state;
   const isStart = !(0, _shims.isNum)(state.lastX);
   const node = findDOMNode(draggable);
@@ -96,6 +127,7 @@ function createCoreData(draggable, x, y) {
       y
     };
   } else {
+    // Otherwise, calculate the delta.
     return {
       node,
       deltaX: x - state.lastX,
@@ -106,10 +138,12 @@ function createCoreData(draggable, x, y) {
       y
     };
   }
-}
+};
 
-// Create an data exposed by <Draggable>'s events
-function createDraggableData(draggable, coreData) {
+// This takes the core data and adjusts it based on the draggable's scale.
+// It's for when you're scaling the draggable and need the position to reflect that.
+exports.createCoreData = createCoreData;
+const createDraggableData = (draggable, coreData) => {
   const scale = draggable.props.scale;
   return {
     node: coreData.node,
@@ -120,21 +154,5 @@ function createDraggableData(draggable, coreData) {
     lastX: draggable.state.x,
     lastY: draggable.state.y
   };
-}
-
-// A lot faster than stringify/parse
-function cloneBounds(bounds) {
-  return {
-    left: bounds.left,
-    top: bounds.top,
-    right: bounds.right,
-    bottom: bounds.bottom
-  };
-}
-function findDOMNode(draggable) {
-  const node = draggable.findDOMNode();
-  if (!node) {
-    throw new Error('<DraggableCore>: Unmounted during event!');
-  }
-  return node;
-}
+};
+exports.createDraggableData = createDraggableData;