fluid-dnd 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Carlos Jorge Rodriguez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+ <h1 align="center">
+    <img src="https://github.com/carlosjorger/vue-fluid-dnd/assets/50055316/dab15832-5290-42ca-b425-db177a2e589e" alt="Icon" width="150" height="140" />
+  <br>Fluid DnD<br>
+</h1>
+
+<div align="center">
+
+![npm bundle size](https://img.shields.io/bundlephobia/minzip/vue-fluid-dnd)
+[![license](https://img.shields.io/github/license/carlosjorger/vue-fluid-dnd?label=license)](https://github.com/carlosjorger/vue-fluid-dnd/blob/main/LICENSE)
+[![version](https://img.shields.io/npm/v/vue-fluid-dnd)](https://www.npmjs.com/package/vue-fluid-dnd)
+![GitHub issues](https://img.shields.io/github/issues/carlosjorger/vue-fluid-dnd)
+![GitHub stars](https://img.shields.io/github/stars/carlosjorger/vue-fluid-dnd)
+[![twitter](https://img.shields.io/twitter/follow/carlosjorgerc)](https://twitter.com/carlosjorgerc)
+[![test_coverage](https://api.codeclimate.com/v1/badges/6b27047dcf150ccddfac/test_coverage)](https://codeclimate.com/github/carlosjorger/vue-fluid-dnd/test_coverage)
+
+</div>
+
+Vue Fluid DnD is a [**fluid**, **smooth** and **versatil** drag and drop
+library for lists on Vue 3](https://vue-fluid-dnd.netlify.app/). It's a**lightweight** tool ~7 Kb (gzip) with no depenencies. This library is a **Vue Draggable Next** alternative if you looking for a better ui experience.
+
+<img src="https://github.com/user-attachments/assets/b350f9a4-7dd7-40ca-ae3f-ecca166a9081" width="100%"/>
+
+## 🧰 Features
+
+- ✅ **Fully customizable 🎨**.
+- ✅ **Zero dependencies 🪶**.
+- ✅ **Work with horizontal➡️and vertical list :arrow_down:**.
+- ✅ **Mouse 🐭 and touch 👉📱 (mobile, tablet and so on) support**.
+- ✅ **Nice documentation 📑 and examples**.
+- ✅ **Fully tested 🧪, typed and reliable**.
+
+## ✨ Inspirations
+
+- ✅ 🎥 Animations by [react-beautiful-dnd](https://github.com/atlassian/react-beautiful-dnd)
+- ✅ 🎨 Api by [Drag & Drop by Formkit](https://drag-and-drop.formkit.com/)
+- ✅ 🧰 Features by [Vue.Draggable](https://github.com/SortableJS/Vue.Draggable)
+
+## 🚀 Getting Started
+
+1. **Install fluid-dnd:**
+
+   ```bash
+   # with npm:
+   npm i fluid-dnd
+
+   # with yarn:
+   yarn add fluid-dnd
+
+   # with pnpm:
+   pnpm i fluid-dnd
+   ```
+
+3. **Documentation**
+
+- 📚 Check out all the [docs](https://vue-fluid-dnd.netlify.app/).
+- 🛠️ Edit the previous [here](https://codesandbox.io/s/nifty-hooks-5plkpl).
+- 📘 See others examples [here](https://vue-fluid-dnd.netlify.app/example/vertical-list/single-vertical-list/).
+
+## 🤝 Contributing
+
+If you're interested in contributing to [vue-fluid-dnd](https://github.com/carlosjorger/vue-fluid-dnd), please read our contributing docs before submitting a pull request [CONTRIBUTING](./CONTRIBUTING.md).
+
+## 🔑 License
+
+- [MIT](https://github.com/carlosjorger/vue-fluid-dnd/blob/main/LICENSE).

package/dist/core/HandlerPublisher.d.ts

@@ -0,0 +1,6 @@
+export default class HandlerPublisher {
+    handlers: Element[];
+    constructor();
+    addSubscriber(subscriber: Element): void;
+    toggleGrabClass(force: boolean): void;
+}

package/dist/core/configHandler.d.ts

@@ -0,0 +1,14 @@
+import { ElementScroll } from "../../index";
+import { CoreConfig } from ".";
+export type DroppableConfig<T> = {
+    droppable: HTMLElement;
+    config: CoreConfig<T>;
+    scroll: ElementScroll;
+};
+export default class ConfigHandler {
+    static configs: DroppableConfig<any>[];
+    static addConfig<T>(droppable: HTMLElement, config: CoreConfig<T>): void;
+    static removeObsoleteConfigs: () => void;
+    static updateScrolls(currentDroppable: Element, droppableGroupClass: string | null): void;
+    static getConfig(curerntDroppable: Element): DroppableConfig<any> | undefined;
+}

package/dist/core/dragAndDrop.d.ts

@@ -0,0 +1,4 @@
+import { ListCondig } from ".";
+import { Config } from ".";
+import HandlerPublisher from "@/core/HandlerPublisher";
+export default function dragAndDrop<T>(listCondig: ListCondig<T>, handlerPublisher: HandlerPublisher, config?: Config<T>, indexAttr?: string): readonly [(index: number) => void, (index: number, value: T) => void, (parent: HTMLElement | undefined) => void];

package/dist/core/index.d.ts

@@ -0,0 +1,149 @@
+import { DraggableElement } from "index";
+export interface ListCondig<T> {
+    removeAtEvent: (index: number) => T | undefined;
+    insertEvent: (index: number, value: T) => void;
+    getLength: () => number;
+    getValue: (index: number) => T;
+    insertToListEmpty: (config: CoreConfig<T>, index: number, value: T) => void;
+}
+export interface DragStartEventData<T> {
+    index: number;
+    element: Element;
+    value: T;
+}
+export interface DragEndEventData<T> {
+    index: number;
+    value: T;
+}
+export declare const HORIZONTAL = "horizontal";
+export declare const VERTICAL = "vertical";
+/**
+ * The direction of the list to sort.
+ * @public
+ */
+export type Direction = typeof HORIZONTAL | typeof VERTICAL;
+/**
+ * Configuration of the drag and drop.
+ * @public
+ */
+export interface Config<T> {
+    /**
+     * The direction of the list to sort.
+     */
+    direction?: Direction;
+    /**
+     * The CSS selector of the drag handler element inside of the draggable element.
+     */
+    handlerSelector?: string;
+    /**
+     * The CSS class that is setted when a element is dragged.
+     */
+    draggingClass?: string;
+    /**
+     * The CSS class that is setted on a droppable element when the current element is dragged over it.
+     */
+    droppableClass?: string;
+    /**
+     * The CSS class that is setted when a element is removed.
+     */
+    removingClass?: string;
+    /**
+     * The CSS class that is setted when a element is start inserting.
+     */
+    insertingFromClass?: string;
+    /**
+     * Delay time before removing an element in milisecond.
+     */
+    delayBeforeRemove?: number;
+    /**
+     * Delay time before inserting an element in milisecond.
+     */
+    delayBeforeInsert?: number;
+    /**
+     * A function that returns whether a given element of the list is draggable.
+     */
+    isDraggable?: (element: HTMLElement) => boolean;
+    /**
+     * A function that returns whether a given element of the list is draggable.
+     */
+    onDragStart?: (element: DragStartEventData<T>) => void;
+    /**
+     * A function that returns whether a given element of the list is draggable.
+     */
+    onDragEnd?: (element: DragEndEventData<T>) => void;
+    /**
+     * Name of the group of the share droppables.
+     */
+    droppableGroup?: string;
+    /**
+     * The duration of the animations in milisecond.
+     */
+    animationDuration?: number;
+}
+/**
+ * onDrop event function.
+ * @public
+ */
+export type OnDropEvent = (source: DraggableElement, destination: DraggableElement) => void;
+export type OnRemoveAtEvent<T> = (index: number) => T | undefined;
+export type OnInsertEvent<T> = (index: number, value: T) => void;
+export type OnGetLength = () => number;
+export type OnGetValue<T> = (index: number) => T;
+export type CoreConfig<T> = {
+    /**
+     * The direction of the list to sort.
+     */
+    direction: Direction;
+    /**
+     * The CSS selector of the drag handler element inside of the draggable element.
+     */
+    handlerSelector: string;
+    /**
+     * The CSS class that is setted when a element is dragged.
+     */
+    draggingClass: string;
+    /**
+     * The CSS class that is setted on a droppable element when the current element is dragged over it.
+     */
+    droppableClass: string;
+    /**
+     * The CSS class that is setted when a element is removed.
+     */
+    removingClass: string;
+    /**
+     * The CSS class that is setted when a element is start inserting.
+     */
+    insertingFromClass: string;
+    /**
+     * Delay time before removing an element in milisecond.
+     */
+    delayBeforeRemove: number;
+    /**
+     * Delay time before inserting an element in milisecond.
+     */
+    delayBeforeInsert: number;
+    /**
+     * A function that returns whether a given element of the list is draggable
+     */
+    isDraggable: (element: HTMLElement) => boolean;
+    /**
+   * A function that is called when the draggable element starts being dragged.
+   */
+    onDragStart: (element: DragStartEventData<T>) => void;
+    /**
+     * A function that is called when the draggable element is dropped.
+     */
+    onDragEnd: (element: DragEndEventData<T>) => void;
+    /**
+     * Name of the group of the share droppables
+     */
+    droppableGroup?: string;
+    /**
+     * The duration of the animations in milisecond
+     */
+    animationDuration: number;
+    onRemoveAtEvent: OnRemoveAtEvent<T>;
+    onInsertEvent: OnInsertEvent<T>;
+    onGetLegth: OnGetLength;
+    onGetValue: OnGetValue<T>;
+};

package/dist/core/useDraggable.d.ts

@@ -0,0 +1,3 @@
+import { CoreConfig } from ".";
+import HandlerPublisher from "./HandlerPublisher";
+export default function useDraggable<T>(draggableElement: HTMLElement, index: number, config: CoreConfig<T>, parent: HTMLElement, handlerPublisher: HandlerPublisher): readonly [(targetIndex: number) => void, (targetIndex: number, value: T) => void];

package/dist/core/useDroppable.d.ts

@@ -0,0 +1,3 @@
+import { CoreConfig } from ".";
+import HandlerPublisher from "./HandlerPublisher";
+export default function useDroppable<T>(coreConfig: CoreConfig<T>, handlerPublisher: HandlerPublisher, droppable?: HTMLElement, indexAttr?: string): readonly [((targetIndex: number) => void)[], ((targetIndex: number, value: T) => void)[]];

package/dist/core/utils/GetStyles.d.ts

@@ -0,0 +1,44 @@
+import { Direction } from "..";
+import { BeforeMargin, AfterMargin, BorderWidth, PaddingBefore, Before } from "../../../index";
+export declare const getWindowScroll: () => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const parseFloatEmpty: (value: string) => number;
+export declare const parseIntEmpty: (value: string | null) => number;
+export declare const getTransform: (element: Element) => {
+    x: number;
+    y: number;
+};
+export declare const draggableIsOutside: (draggable: Element, droppable: Element) => boolean;
+export declare const hasIntersection: (element1: Element, element2: Element) => boolean;
+export declare const getValueFromProperty: (element: HTMLElement | Element | undefined | null, property: PaddingBefore | BorderWidth | BeforeMargin | AfterMargin | Before) => number;
+export declare const getScrollElement: (element: HTMLElement) => {
+    scrollLeft: number;
+    scrollTop: number;
+};
+export declare const getPropByDirection: (direction: Direction) => {
+    readonly beforeMargin: "marginTop" | "marginLeft";
+    readonly afterMargin: "marginBottom" | "marginRight";
+    readonly borderBeforeWidth: "borderTopWidth" | "borderLeftWidth";
+    readonly before: "left" | "top";
+    readonly after: "right" | "down";
+    readonly gap: "columnGap" | "rowGap";
+    readonly distance: "width" | "height";
+    readonly axis: "x" | "y";
+    readonly offset: "offsetX" | "offsetY";
+    readonly scroll: "scrollX" | "scrollY";
+    readonly scrollElement: "scrollLeft" | "scrollTop";
+    readonly page: "pageX" | "pageY";
+    readonly inner: "innerWidth" | "innerHeight";
+    readonly offsetElement: "offsetLeft" | "offsetTop";
+    readonly scrollDistance: "scrollWidth" | "scrollHeight";
+    readonly clientDistance: "clientWidth" | "clientHeight";
+    readonly paddingBefore: "paddingLeft" | "paddingTop";
+    readonly getRect: (element: Element) => DOMRect;
+};
+export declare const getSiblings: (current: HTMLElement, parent: HTMLElement) => readonly [Element[], number, HTMLElement];
+export declare const getGroupDroppables: (currentDroppable: HTMLElement, droppableGroup?: string) => Element[];
+export declare const getParentDraggableChildren: (parent: HTMLElement) => Element[];
+export declare const getSiblingsByParent: (current: HTMLElement, parent: HTMLElement) => readonly [Element[], number, HTMLElement];
+export declare const getNearestFixedParentPosition: (element: Element, direction: Direction) => number;

package/dist/core/utils/ParseStyles.d.ts

@@ -0,0 +1,7 @@
+import { GapStyle } from "../../../index";
+import { Direction } from "..";
+export declare const getNumberFromPixels: (pixels: string | undefined) => number;
+export declare const computeGapPixels: (element: Element, gapType: GapStyle) => number;
+export declare const gapAndDisplayInformation: (element: Element | null, gapStyle: GapStyle) => [number, boolean];
+export declare const getBeforeStyles: (element: HTMLElement) => [number, number];
+export declare const getGapPixels: (element: HTMLElement, direction: Direction) => number;

package/dist/core/utils/SetStyles.d.ts

@@ -0,0 +1,19 @@
+import { DragMouseTouchEvent, fixedSize } from "../../../index";
+type onTouchEvent = "ontouchstart" | "ontouchmove" | "ontouchend";
+declare const onMouseEvents: readonly ["onmouseup", "onmousedown", "onmousemove"];
+type onMouseEvent = (typeof onMouseEvents)[number];
+type TouchEventType = "touchstart" | "touchmove" | "touchend";
+declare const mouseEvents: readonly ["mouseup", "mousedown", "mousemove"];
+type MouseEventType = (typeof mouseEvents)[number];
+type DragEventCallback = (event: DragMouseTouchEvent) => void;
+export declare const setSizeStyles: (element: HTMLElement | undefined | null, height: number, width: number) => void;
+export declare const fixSizeStyle: (element: HTMLElement | undefined | null) => void;
+export declare const moveTranslate: (element: Element | undefined | null, height: number, width: number) => void;
+export declare const assignDraggingEvent: (element: HTMLElement, onEvent: onMouseEvent | onTouchEvent, callback: DragEventCallback | null) => void;
+export declare const addDragMouseToucEventListener: (event: TouchEventType | MouseEventType, callback: DragEventCallback | null) => void;
+export declare const convetEventToDragMouseTouchEvent: (event: MouseEvent | TouchEvent) => DragMouseTouchEvent;
+export declare const setTranistion: (element: Element | undefined, duration: number, timingFunction?: string, types?: string) => void;
+export declare const setEventWithInterval: (element: Element | undefined, eventName: "onscroll", callback: () => void) => void;
+export declare const AddCssStylesToElement: (node: ParentNode, cssCodes: string[]) => void;
+export declare const setCustomFixedSize: (element: HTMLElement | undefined, fixedProps?: fixedSize) => void;
+export {};

package/dist/core/utils/SetTransform.d.ts

@@ -0,0 +1,7 @@
+import { DragMouseTouchEvent, TransformEvent } from "../../../index";
+import { Direction } from "..";
+export declare const useTransform: (draggedElement: HTMLElement) => readonly [(element: HTMLElement, parent: HTMLElement, pagePosition: {
+    pageX: number;
+    pageY: number;
+}, direction?: Direction) => void, (event: DragMouseTouchEvent, element: HTMLElement) => void];
+export declare const getTransformState: (event: TransformEvent, element: HTMLElement, draggable: Element) => [number, number, number, number];

package/dist/core/utils/classes.d.ts

@@ -0,0 +1,9 @@
+export declare const DRAGGABLE_CLASS = "draggable";
+export declare const DROPPABLE_CLASS = "droppable";
+export declare const HANDLER_CLASS = "handler-class";
+export declare const DRAGGING_CLASS = "dragging";
+export declare const DRAGGING_HANDLER_CLASS = "dragging-handler-class";
+export declare const DROPPING_CLASS = "dropping";
+export declare const GRABBING_CLASS = "grabbing";
+export declare const GRAB_CLASS = "grab";
+export declare const DISABLE_TRANSITION = "disable-transition";

package/dist/core/utils/config.d.ts

@@ -0,0 +1,3 @@
+import { ListCondig } from "..";
+import { Config, CoreConfig } from "..";
+export declare const getConfig: <T>(listCondig: ListCondig<T>, config?: Config<T>) => CoreConfig<T>;

package/dist/core/utils/dom/classList.d.ts

@@ -0,0 +1,8 @@
+export declare const containClass: (element: Element, cssClass: string) => boolean;
+export declare const toggleClass: (element: Element, cssClass: string, force?: boolean) => void;
+export declare const addClass: (element: Element, cssClass: string) => void;
+export declare const removeClass: (element: Element, cssClass: string) => void;
+export declare const containstClasses: (element: HTMLElement, classes: string) => boolean;
+export declare const getClassesSelector: (classes: string | null) => string;
+export declare const addMultipleClasses: (element: HTMLElement, classes: string | null) => void;
+export declare const getClassesList: (classes: string | null | undefined) => string[];

package/dist/core/utils/droppableConfigurator.d.ts

@@ -0,0 +1,22 @@
+import { DroppableConfig } from "../configHandler";
+import { DragMouseTouchEvent } from "../../../index";
+export declare class DroppableConfigurator<T> {
+    initial: DroppableConfig<any> | undefined;
+    current: DroppableConfig<T> | undefined;
+    private parent;
+    private draggableElement;
+    private groupClass;
+    private dragEvent;
+    private changeDroppable;
+    constructor(draggableElement: HTMLElement, droppableGroupClass: string | null, parent: HTMLElement, setTransformDragEvent: () => void, changeDroppable: (newdDroppableConfig: DroppableConfig<T> | undefined, oldDroppableConfig: DroppableConfig<T> | undefined) => void);
+    private getDraggableAncestor;
+    private getElementBelow;
+    private getCurrent;
+    private isOutsideOfAllDroppables;
+    private isNotInsideAnotherDroppable;
+    private onScrollEvent;
+    private setOnScroll;
+    getCurrentConfig(event: DragMouseTouchEvent): DroppableConfig<any> | DroppableConfig<T> | undefined;
+    updateConfig(event: DragMouseTouchEvent): void;
+    isOutside(event: DragMouseTouchEvent, hiddenDraggable?: boolean): boolean;
+}

package/dist/core/utils/events/emitEvents.d.ts

@@ -0,0 +1,11 @@
+import { WindowScroll } from "../../../../index";
+import { CoreConfig } from "../..";
+import { DRAG_EVENT, START_DRAG_EVENT, START_DROP_EVENT } from "..";
+import { DroppableConfig } from "../../configHandler";
+import HandlerPublisher from '../../HandlerPublisher';
+type DraggingEvent = typeof DRAG_EVENT | typeof START_DRAG_EVENT;
+type DragAndDropEvent = DraggingEvent | DropEvent;
+type DropEvent = "drop" | typeof START_DROP_EVENT;
+export default function useEmitEvents<T>(currentConfig: CoreConfig<T>, index: number, parent: HTMLElement, droppableGroupClass: string | null, handlerPublisher: HandlerPublisher, endDraggingAction: () => void): readonly [(draggedElement: HTMLElement, event: DragAndDropEvent, initialWindowScroll: WindowScroll, droppableConfig: DroppableConfig<T> | undefined, positionOnSourceDroppable?: number) => void, (targetIndex: number, draggedElement: HTMLElement, droppableConfig: DroppableConfig<T>, onFinishRemoveEvent: (element: HTMLElement) => void) => void, (targetIndex: number, draggedElement: HTMLElement, droppable: HTMLElement, value: T, startInserting: () => void) => void, (draggedElement: HTMLElement) => void, (element: Element, force: boolean) => void];
+export declare const insertToListEmpty: <T>(config: CoreConfig<T>, droppable: HTMLElement | undefined, targetIndex: number, value: T) => void;
+export {};

package/dist/core/utils/index.d.ts

@@ -0,0 +1,10 @@
+export declare const START_DRAG_EVENT = "startDrag";
+export declare const DRAG_EVENT = "drag";
+export declare const START_DROP_EVENT = "startDrop";
+export declare const DROP_EVENT = "drop";
+export declare const TEMP_CHILD_CLASS = "temp-child";
+export declare const draggableTargetTimingFunction = "cubic-bezier(0.2, 0, 0, 1)";
+export type DraggingEvent = typeof DRAG_EVENT | typeof START_DRAG_EVENT;
+export type DropEvent = typeof DROP_EVENT | typeof START_DROP_EVENT;
+export type DragAndDropEvent = DraggingEvent | DropEvent | "remove" | "insert";
+export declare const IsDropEvent: (event: DragAndDropEvent) => event is DropEvent;

package/dist/core/utils/observer.d.ts

@@ -0,0 +1 @@
+export declare const observeMutation: (callback: (observer: MutationObserver, mutation: MutationRecord) => void, element: Element, options?: MutationObserverInit) => MutationObserver;

package/dist/core/utils/scroll.d.ts

@@ -0,0 +1,4 @@
+import { ElementScroll } from "index";
+import { Direction } from "..";
+export declare const scrollByDirection: (element: HTMLElement, direction: Direction, scrollAmount: number) => void;
+export declare const scrollPercent: (direction: Direction, droppable: HTMLElement, droppableScroll: ElementScroll) => number;

package/dist/core/utils/tempChildren.d.ts

@@ -0,0 +1,5 @@
+import { DroppableConfig } from "../configHandler";
+export declare const addTempChild: <T>(draggedElement: HTMLElement | undefined, parent: Element, ifStartDragging: boolean, droppableConfig?: DroppableConfig<T>, addingAnimationDuration?: number) => void;
+export declare const addTempChildOnInsert: <T>(draggedElement: HTMLElement | undefined, ifStartDragging: boolean, droppableConfig?: DroppableConfig<T>) => void;
+export declare const removeTempChildrens: (droppable: HTMLElement, parent: HTMLElement, droppableGroupClass: string | null, animationDuration: number, draggedElementIsOutside?: boolean) => void;
+export declare const removeTempChild: (parent: HTMLElement, animationDuration: number, isAnimated?: boolean) => void;

package/dist/core/utils/touchDevice.d.ts

@@ -0,0 +1,3 @@
+export declare const isTouchEvent: (event: MouseEvent | TouchEvent) => event is TouchEvent;
+export declare const IsHTMLElement: (element: Element | undefined) => element is HTMLElement;
+export declare const IsMouseEvent: (event: MouseEvent | TouchEvent) => event is MouseEvent;

package/dist/core/utils/translate/GetTranslateBeforeDropping.d.ts

@@ -0,0 +1,6 @@
+import { Direction } from "../..";
+import { Translate, WindowScroll } from "../../../../index";
+export default function getTranslateBeforeDropping(direction: Direction, siblings: Element[], sourceIndex: number, targetIndex: number, scroll: WindowScroll, previousScroll: {
+    scrollLeft: number;
+    scrollTop: number;
+}, initialWindowScroll: WindowScroll, droppable: HTMLElement, draggable?: HTMLElement): Translate;

package/dist/core/utils/translate/GetTranslationByDraggingAndEvent.d.ts

@@ -0,0 +1,6 @@
+import { Direction } from "../..";
+import { DragAndDropEvent } from "..";
+export default function getTranslationByDraggingAndEvent(current: HTMLElement, event: DragAndDropEvent, direction: Direction, droppable: HTMLElement, previousElement?: Element | null, nextElement?: Element | null): {
+    height: number;
+    width: number;
+};