@atlaskit/pragmatic-drag-and-drop 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/pragmatic-drag-and-drop
 
+## 0.18.0
+
+### Minor Changes
+
+- [`9fd8556db17`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9fd8556db17) - Internal folder name structure change
+
 ## 0.17.0
 
 ### Minor Changes

package/README.md

@@ -40,4 +40,4 @@ yarn add @atlaskit/pragmatic-drag-and-drop
 
 ## Usage
 
-Detailed docs and example usage can be found on [atlassian.design](https://atlassian.design/components/atlassian-drag-and-drop/).
+Detailed docs and example usage can be found on [atlassian.design](https://atlassian.design/components/pragmatic-drag-and-drop/).

package/constellation/index/about.mdx

@@ -8,8 +8,8 @@ import SectionMessage from '@atlaskit/section-message';
 
 This package contains the essential pieces of the system, and is not tied to any JavaScript framework.
 
-- The [element adapter](/components/drag-and-drop/adapter/element-adapter) powers drag operations of elements.
-- The [file adapter](/components/drag-and-drop/adapter/file-adapter) powers drag operations of external files.
+- The [element adapter](/components/pragmatic-drag-and-drop/adapter/element-adapter) powers drag operations of elements.
+- The [file adapter](/components/pragmatic-drag-and-drop/adapter/file-adapter) powers drag operations of external files.
 - All of the base TypeScript types of Pragmatic drag and drop are in `@atlaskit/pragmatic-drag-and-drop/types`.
 
 ## Addons
@@ -308,7 +308,7 @@ A function that scrolls a draggable element just enough into view so that the el
 import { scrollJustEnoughIntoView } from '@atlaskit/pragmatic-drag-and-drop/util/scroll-just-enough-into-view';
 ```
 
-Useful to avoid having drag previews cut off by scroll containers. See [element adapter](/components/drag-and-drop/adapter/element-adapter) for more information.
+Useful to avoid having drag previews cut off by scroll containers. See [element adapter](/components/pragmatic-drag-and-drop/adapter/element-adapter) for more information.
 
 ```ts
 import { scrollJustEnoughIntoView } from '@atlaskit/pragmatic-drag-and-drop/util/scroll-just-enough-into-view';

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/pragmatic-drag-and-drop",
-	"version": "0.17.0",
+	"version": "0.18.0",
 	"sideEffects": false
 }

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/pragmatic-drag-and-drop",
-	"version": "0.17.0",
+	"version": "0.18.0",
 	"sideEffects": false
 }

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/pragmatic-drag-and-drop",
-	"version": "0.17.0",
+	"version": "0.18.0",
 	"sideEffects": false
 }

package/dist/types-ts4.0/adapter/element-adapter.d.ts

@@ -0,0 +1,42 @@
+import { AllEvents, BaseEventPayload, CleanupFn, DropTargetEventPayloadMap, EventPayloadMap, Input, InternalDragType, MonitorCanMonitorArgs } from '../internal-types';
+declare type ElementDragType = InternalDragType<'element', 'move', {
+    element: HTMLElement;
+    dragHandle: Element | null;
+    data: Record<string, unknown>;
+}>;
+declare type GetFeedbackArgs = {
+    /**
+     * The user input as a drag is trying to start (the `initial` input)
+     */
+    input: Input;
+    /**
+     * The `draggable` element
+     */
+    element: HTMLElement;
+    /**
+     * The `dragHandle` element for the `draggable`
+     */
+    dragHandle: Element | null;
+};
+declare type DraggableArgs = {
+    /** The `HTMLElement` that you want to attach draggable behaviour to.
+     * `element` is our unique _key_ for a draggable.
+     * `element` is a `HTMLElement` as only a `HTMLElement`
+     * can have a "draggable" attribute
+     */
+    element: HTMLElement;
+    /** The part of a draggable `element` that you want to use to control the dragging of the whole `element` */
+    dragHandle?: Element;
+    /** Conditionally allow a drag to occur */
+    canDrag?: (args: GetFeedbackArgs) => boolean;
+    /** Used to attach data to a drag operation. Called once just before the drag starts */
+    getInitialData?: (args: GetFeedbackArgs) => Record<string, unknown>;
+} & Partial<AllEvents<ElementDragType>>;
+export declare const dropTargetForElements: (args: import("../internal-types").DropTargetArgs<ElementDragType>) => CleanupFn;
+export declare const monitorForElements: (args: import("../internal-types").MonitorArgs<ElementDragType>) => CleanupFn;
+export declare function draggable(args: DraggableArgs): CleanupFn;
+export declare type ElementEventBasePayload = BaseEventPayload<ElementDragType>;
+export declare type ElementEventPayloadMap = EventPayloadMap<ElementDragType>;
+export declare type ElementDropTargetEventPayloadMap = DropTargetEventPayloadMap<ElementDragType>;
+export declare type ElementMonitorCanMonitorArgs = MonitorCanMonitorArgs<ElementDragType>;
+export {};

package/dist/types-ts4.0/adapter/file-adapter.d.ts

@@ -0,0 +1,18 @@
+import { BaseEventPayload, CleanupFn, DropTargetEventPayloadMap, EventPayloadMap, ExternalDragType, MonitorCanMonitorArgs } from '../internal-types';
+declare type FileDragType = ExternalDragType<'file', 'copy', {
+    items: DataTransfer['items'] | null;
+}>;
+declare const adapter: {
+    registerUsage: () => CleanupFn;
+    dropTarget: (args: import("../internal-types").DropTargetArgs<FileDragType>) => CleanupFn;
+    monitor: (args: import("../internal-types").MonitorArgs<FileDragType>) => CleanupFn;
+};
+declare type StripEventsForDropTargets<T> = Omit<T, 'onDragStart' | 'onGenerateDragPreview'>;
+declare type StripPreviewEvent<T> = Omit<T, 'onGenerateDragPreview'>;
+export declare const dropTargetForFiles: (args: StripEventsForDropTargets<Parameters<typeof adapter.dropTarget>[0]>) => CleanupFn;
+export declare const monitorForFiles: (args: StripPreviewEvent<Parameters<typeof adapter.monitor>[0]>) => CleanupFn;
+export declare type FileDropTargetEventPayloadMap = StripEventsForDropTargets<DropTargetEventPayloadMap<FileDragType>>;
+export declare type FileEventPayloadMap = StripPreviewEvent<EventPayloadMap<FileDragType>>;
+export declare type FileEventBasePayload = BaseEventPayload<FileDragType>;
+export declare type FileMonitorCanMonitorArgs = MonitorCanMonitorArgs<FileDragType>;
+export {};

package/dist/types-ts4.0/addon/cancel-unhandled.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Block drag operations outside of `@atlaskit/pragmatic-drag-and-drop`
+ */
+export declare const cancelUnhandled: {
+    start(): void;
+    stop(): void;
+};

package/dist/types-ts4.0/entry-point/adapter/element.d.ts

@@ -0,0 +1,2 @@
+export { draggable, dropTargetForElements, monitorForElements, } from '../../adapter/element-adapter';
+export type { ElementEventBasePayload, ElementEventPayloadMap, ElementDropTargetEventPayloadMap, ElementMonitorCanMonitorArgs, } from '../../adapter/element-adapter';

package/dist/types-ts4.0/entry-point/adapter/file.d.ts

@@ -0,0 +1,2 @@
+export { monitorForFiles, dropTargetForFiles, } from '../../adapter/file-adapter';
+export type { FileEventBasePayload, FileDropTargetEventPayloadMap, FileEventPayloadMap, FileMonitorCanMonitorArgs, } from '../../adapter/file-adapter';

package/dist/types-ts4.0/entry-point/addon/cancel-unhandled.d.ts

@@ -0,0 +1 @@
+export { cancelUnhandled } from '../../addon/cancel-unhandled';

package/dist/types-ts4.0/entry-point/experimental/cross-with-element-adapter.d.ts

@@ -0,0 +1 @@
+export { setCrossWindowData, extractCrossWindowResult, dropTargetForCrossWindowElements, monitorForCrossWindowElements, } from '../../experimental/cross-window-element-adapter';

package/dist/types-ts4.0/entry-point/types.d.ts

@@ -0,0 +1 @@
+export type { DropTargetRecord, Position, SourceCanStartArgs, Input, DragLocation, DragLocationHistory, CleanupFn, } from '../internal-types';

package/dist/types-ts4.0/entry-point/util/combine.d.ts

@@ -0,0 +1 @@
+export { combine } from '../../util/combine';

package/dist/types-ts4.0/entry-point/util/disable-native-drag-preview.d.ts

@@ -0,0 +1 @@
+export { disableNativeDragPreview } from '../../util/disable-native-drag-preview';

package/dist/types-ts4.0/entry-point/util/once.d.ts

@@ -0,0 +1 @@
+export { once } from '../../util/once';

package/dist/types-ts4.0/entry-point/util/reorder.d.ts

@@ -0,0 +1 @@
+export { reorder } from '../../util/reorder';

package/dist/types-ts4.0/entry-point/util/scroll-just-enough-into-view.d.ts

@@ -0,0 +1 @@
+export { scrollJustEnoughIntoView } from '../../util/scroll-just-enough-into-view';

package/dist/types-ts4.0/entry-point/util/set-custom-native-drag-preview.d.ts

@@ -0,0 +1 @@
+export { setCustomNativeDragPreview } from '../../util/set-custom-native-drag-preview';

package/dist/types-ts4.0/experimental/cross-window-element-adapter.d.ts

@@ -0,0 +1,17 @@
+import { CleanupFn, ExternalDragType, Serializable } from '../internal-types';
+declare type CrossWindowResult = 'moved' | 'none';
+declare type CrossWindowDragType = ExternalDragType<'experimental-cross-window-element', 'move', {
+    data: Serializable;
+}>;
+declare const adapter: {
+    registerUsage: () => CleanupFn;
+    dropTarget: (args: import("../internal-types").DropTargetArgs<CrossWindowDragType>) => CleanupFn;
+    monitor: (args: import("../internal-types").MonitorArgs<CrossWindowDragType>) => CleanupFn;
+};
+export declare function setCrossWindowData({ data }: {
+    data: Serializable;
+}): void;
+export declare function extractCrossWindowResult(): CrossWindowResult | null;
+export declare const dropTargetForCrossWindowElements: (args: Parameters<typeof adapter.dropTarget>[0]) => CleanupFn;
+export declare const monitorForCrossWindowElements: (args: import("../internal-types").MonitorArgs<CrossWindowDragType>) => CleanupFn;
+export {};

package/dist/types-ts4.0/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/types-ts4.0/internal-types.d.ts

@@ -0,0 +1,275 @@
+export declare type CleanupFn = () => void;
+/**
+ * Information about a drop target
+ */
+export declare type DropTargetRecord = {
+    /**
+     * The element the drop target is attached to
+     */
+    element: Element;
+    /**
+     * Data associated with the drop target
+     *
+     * (Collected by `getData()`)
+     */
+    data: Record<string | symbol, unknown>;
+    /**
+     * The drop effect for the drop target
+     *
+     * (Collected by `getDropEffect()`)
+     */
+    dropEffect: DataTransfer['dropEffect'];
+    /**
+     * Whether or not the drop target is sticky
+     *
+     * (Collected by `getIsSticky()`)
+     */
+    sticky: boolean;
+};
+export declare type Position = {
+    x: number;
+    y: number;
+};
+export declare type Serializable = {
+    [key: string]: number | string | Serializable | Serializable[];
+};
+export declare type InternalDragType<Key extends string, DefaultDropEffect extends DataTransfer['dropEffect'], Payload extends Record<string, unknown>> = {
+    key: Key;
+    defaultDropEffect: DefaultDropEffect;
+    startedFrom: 'internal';
+    payload: Payload;
+};
+export declare type ExternalDragType<Key extends string, DefaultDropEffect extends DataTransfer['dropEffect'], Payload extends Record<string, unknown>> = {
+    key: Key;
+    startedFrom: 'external';
+    defaultDropEffect: DefaultDropEffect;
+    payload: Payload;
+};
+export declare type DragInterface<DragType extends AllDragTypes> = DragType extends ExternalDragType<string, DataTransfer['dropEffect'], Record<string, unknown>> ? // External drag types might need to refresh their source
+Omit<DragType, 'defaultDropEffect'> & {
+    getDropPayload?: (event: DragEvent) => DragType['payload'];
+} : Omit<DragType, 'defaultDropEffect'>;
+export declare type AllDragTypes = InternalDragType<string, DataTransfer['dropEffect'], Record<string, unknown>> | ExternalDragType<string, DataTransfer['dropEffect'], Record<string, unknown>>;
+export declare type SourceCanStartArgs = {
+    event: DragEvent;
+    input: Input;
+};
+export declare type AdapterAPI<DragType extends AllDragTypes> = {
+    canStart: (event: DragEvent) => boolean;
+    start: (args: {
+        event: DragEvent;
+        dragInterface: DragInterface<DragType>;
+    }) => void;
+};
+export declare type Input = {
+    altKey: boolean;
+    button: number;
+    buttons: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+};
+export declare type DragLocation = {
+    /**
+     * A users input at a point in time
+     */
+    input: Input;
+    /**
+     * A _bubble_ ordered (innermost upwards) list of active drop targets
+     *
+     * @example
+     * [grandChildRecord, childRecord, parentRecord]
+     *
+     */
+    dropTargets: DropTargetRecord[];
+};
+export declare type DragLocationHistory = {
+    /**
+     * Where the drag operation started
+     */
+    initial: DragLocation;
+    /**
+     * Where the user currently is
+     */
+    current: DragLocation;
+    /**
+     * Where the user was previously.
+     * `previous` points to what `current` was in the last dispatched event
+     *
+     * `previous` is particularly useful for `onDropTargetChange`
+     * (and the derived `onDragEnter` and `onDragLeave`)
+     * as you can know what the delta of the change
+     *
+     * Exception: `onGenerateDragPreview` and `onDragStart` will have the
+     * same `current` and `previous` values. This is done so that the data
+     * received in `onDragStart` feels logical
+     * (`location.previous` should be `[]` in `onDragStart`)
+     */
+    previous: Pick<DragLocation, 'dropTargets'>;
+};
+/**
+ * The common data that is provided to all events
+ */
+export declare type BaseEventPayload<DragType extends AllDragTypes> = {
+    /**
+     * Location history for the drag operation
+     */
+    location: DragLocationHistory;
+    /**
+     * Data associated with the entity that is being dragged
+     */
+    source: DragType['payload'];
+};
+export declare type EventPayloadMap<DragType extends AllDragTypes> = {
+    /**
+     * Drag is about to start.
+     * Make changes you want to see in the drag preview
+     *
+     * _Drag previews are not generated for external drag sources (eg files)_
+     */
+    onGenerateDragPreview: BaseEventPayload<DragType> & {
+        /**
+         * Allows you to use the native `setDragImage` function if you want
+         * Although, we recommend using alternative techniques (see element adapter docs)
+         */
+        nativeSetDragImage: DataTransfer['setDragImage'] | null;
+    };
+    /**
+     * A drag operation has started. You can make changes to the DOM and those changes won't be reflected in your _drag preview_
+     */
+    onDragStart: BaseEventPayload<DragType>;
+    /**
+     * A throttled update of where the the user is currently dragging. Useful if you want to create a high fidelity experience such as drawing.
+     */
+    onDrag: BaseEventPayload<DragType>;
+    /**
+     * The `onDropTargetChange` event fires when the `dropTarget` hierarchy changes during a drag.
+     */
+    onDropTargetChange: BaseEventPayload<DragType>;
+    /**
+     * The `onDrop` event occurs when a user has finished a drag and drop operation.
+     * The `onDrop` event will fire when the drag operation finishes, regardless of how the drag operation finished
+     * (eg due to an explicit drop, the drag being canceled, recovering from an error and so on). On the web platform
+     * we cannot distinguish between dropping on no drop targets and an explicit cancel, so we do not publish any
+     * information about _how_ the drag ended, only that it ended.
+     *
+     * The `location.current` property will accurately contain the final drop targets.
+     */
+    onDrop: BaseEventPayload<DragType>;
+};
+export declare type AllEvents<DragType extends AllDragTypes> = {
+    [EventName in keyof EventPayloadMap<DragType>]: (args: EventPayloadMap<DragType>[EventName]) => void;
+};
+export declare type MonitorCanMonitorArgs<DragType extends AllDragTypes> = {
+    /**
+     * The users `initial` drag location
+     */
+    initial: DragLocation;
+    /**
+     * The data associated with the entity being dragged
+     */
+    source: DragType['payload'];
+};
+export declare type MonitorArgs<DragType extends AllDragTypes> = Partial<AllEvents<DragType>> & {
+    canMonitor?: (args: MonitorCanMonitorArgs<DragType>) => boolean;
+};
+export declare type DropTargetGetFeedbackArgs<DragType extends AllDragTypes> = {
+    /**
+     * The users _current_ input
+     */
+    input: Input;
+    /**
+     * The data associated with the entity being dragged
+     */
+    source: DragType['payload'];
+    /**
+     * This drop target's element
+     */
+    element: Element;
+};
+export declare type DropTargetLocalizedData = {
+    /**
+     * A convenance pointer to this drop targets values
+     */
+    self: DropTargetRecord;
+};
+/**
+ * Mapping event names to the payloads for those events
+ */
+export declare type DropTargetEventPayloadMap<DragType extends AllDragTypes> = {
+    [EventName in keyof EventPayloadMap<DragType>]: EventPayloadMap<DragType>[EventName] & DropTargetLocalizedData;
+} & {
+    /**
+     * Derived from the `onDropTargetChange` event
+     * (`onDragEnter` is not it's own event that bubbles)
+     *
+     * `onDragEnter` is fired when _this_ drop target is entered into
+     * and not when any child drop targets change
+     */
+    onDragEnter: EventPayloadMap<DragType>['onDropTargetChange'] & DropTargetLocalizedData;
+    /**
+     * Derived from the `onDropTargetChange` event
+     * (`onDragLeave` is not it's own event that bubbles)
+     *
+     * `onDragLeave` is fired when _this_ drop target is exited from
+     * and not when any child drop targets change
+     */
+    onDragLeave: EventPayloadMap<DragType>['onDropTargetChange'] & DropTargetLocalizedData;
+};
+export declare type DropTargetArgs<DragType extends AllDragTypes> = {
+    /**
+     * The `element` that you want to attach drop target behaviour to.
+     * The `element` is the unique _key_ for a drop target
+     */
+    element: Element;
+    /**
+     * A function that returns `data` you want to attach to the drop target.
+     * `getData()` is called _repeatedly_ while the user is dragging over the drop target in order to power addons
+     */
+    getData?: (args: DropTargetGetFeedbackArgs<DragType>) => Record<string | symbol, unknown>;
+    /**
+     * Used to conditionally block dropping.
+     * By default a drop target can be dropped on.
+     *
+     * Return `false` if you want to block a drop.
+     *
+     * `canDrop()` is called _repeatedly_ while a drop target
+     * is being dragged over to allow you to dynamically
+     * change your mind as to whether a drop target can be
+     * dropped on.
+     */
+    canDrop?: (args: DropTargetGetFeedbackArgs<DragType>) => boolean;
+    /**
+     * Optionally provide a _drop effect_ to be applied when
+     * this drop target is the innermost drop target being dragged over
+     */
+    getDropEffect?: (args: DropTargetGetFeedbackArgs<DragType>) => DataTransfer['dropEffect'];
+    /**
+     * Return `true` if you want your drop target to hold onto
+     * selection after the user is no longer dragging over this drop target.
+     *
+     * Stickiness defaults to `false`
+     *
+     * _For more details about the stickiness algorithm please refer to the docs_
+     */
+    getIsSticky?: (args: DropTargetGetFeedbackArgs<DragType>) => boolean;
+} & {
+    [EventName in keyof DropTargetEventPayloadMap<DragType>]?: (args: DropTargetEventPayloadMap<DragType>[EventName]) => void;
+};
+export declare type DropTargetAPI<DragType extends AllDragTypes> = {
+    dropTargetForConsumers: (args: DropTargetArgs<DragType>) => CleanupFn;
+    dispatchEvent: <EventName extends keyof EventPayloadMap<DragType>>(args: {
+        eventName: EventName;
+        payload: EventPayloadMap<DragType>[EventName];
+    }) => void;
+    getIsOver: (args: {
+        source: DragType['payload'];
+        target: EventTarget | null;
+        input: Input;
+        current: DropTargetRecord[];
+    }) => DropTargetRecord[];
+};

package/dist/types-ts4.0/ledger/dispatch-consumer-event.d.ts

@@ -0,0 +1,26 @@
+import { AllDragTypes, DragLocation, EventPayloadMap } from '../internal-types';
+export declare function makeDispatch<DragType extends AllDragTypes>({ source, initial, dispatchEvent, }: {
+    source: DragType['payload'];
+    initial: DragLocation;
+    dispatchEvent: <EventName extends keyof EventPayloadMap<DragType>>(args: {
+        eventName: EventName;
+        payload: EventPayloadMap<DragType>[EventName];
+    }) => void;
+}): {
+    start({ nativeSetDragImage, }: {
+        nativeSetDragImage: DataTransfer['setDragImage'] | null;
+    }): void;
+    dragUpdate({ current }: {
+        current: DragLocation;
+    }): void;
+    drag({ current }: {
+        current: DragLocation;
+    }): void;
+    drop({ current, updatedExternalPayload: updatedSourcePayload, }: {
+        current: DragLocation;
+        /** When dragging from an external source, we need to collect the
+            drag source information again as it is often only available during
+            the "drop" event */
+        updatedExternalPayload: DragType['payload'] | null;
+    }): void;
+};

package/dist/types-ts4.0/ledger/lifecycle-manager.d.ts

@@ -0,0 +1,16 @@
+import { AllDragTypes, DragInterface, DropTargetAPI, EventPayloadMap } from '../internal-types';
+declare function canStart(): boolean;
+declare function start<DragType extends AllDragTypes>({ event, dragInterface, getDropTargetsOver, dispatchEvent, }: {
+    event: DragEvent;
+    dragInterface: DragInterface<DragType>;
+    getDropTargetsOver: DropTargetAPI<DragType>['getIsOver'];
+    dispatchEvent: <EventName extends keyof EventPayloadMap<DragType>>(args: {
+        eventName: EventName;
+        payload: EventPayloadMap<DragType>[EventName];
+    }) => void;
+}): void;
+export declare const lifecycle: {
+    canStart: typeof canStart;
+    start: typeof start;
+};
+export {};

package/dist/types-ts4.0/ledger/usage-ledger.d.ts

@@ -0,0 +1,5 @@
+import { AllDragTypes, CleanupFn } from '../internal-types';
+export declare function register<TypeKey extends AllDragTypes['key']>(args: {
+    typeKey: TypeKey;
+    mount: () => CleanupFn;
+}): CleanupFn;

package/dist/types-ts4.0/make-adapter/make-adapter.d.ts

@@ -0,0 +1,14 @@
+import { AdapterAPI, AllDragTypes, CleanupFn, EventPayloadMap } from '../internal-types';
+export declare function makeAdapter<DragType extends AllDragTypes>({ typeKey, mount, dispatchEventToSource, defaultDropEffect, }: {
+    typeKey: DragType['key'];
+    mount: (api: AdapterAPI<DragType>) => CleanupFn;
+    defaultDropEffect: DragType['defaultDropEffect'];
+    dispatchEventToSource?: <EventName extends keyof EventPayloadMap<DragType>>(args: {
+        eventName: EventName;
+        payload: EventPayloadMap<DragType>[EventName];
+    }) => void;
+}): {
+    registerUsage: () => CleanupFn;
+    dropTarget: (args: import("../internal-types").DropTargetArgs<DragType>) => CleanupFn;
+    monitor: (args: import("../internal-types").MonitorArgs<DragType>) => CleanupFn;
+};

package/dist/types-ts4.0/make-adapter/make-drop-target.d.ts

@@ -0,0 +1,5 @@
+import { AllDragTypes, DropTargetAPI } from '../internal-types';
+export declare function makeDropTarget<DragType extends AllDragTypes>({ typeKey, defaultDropEffect, }: {
+    typeKey: DragType['key'];
+    defaultDropEffect: DataTransfer['dropEffect'];
+}): DropTargetAPI<DragType>;

package/dist/types-ts4.0/make-adapter/make-monitor.d.ts

@@ -0,0 +1,8 @@
+import { AllDragTypes, CleanupFn, EventPayloadMap, MonitorArgs } from '../internal-types';
+export declare function makeMonitor<DragType extends AllDragTypes>(): {
+    dispatchEvent: <EventName extends keyof EventPayloadMap<DragType>>({ eventName, payload, }: {
+        eventName: EventName;
+        payload: EventPayloadMap<DragType>[EventName];
+    }) => void;
+    monitorForConsumers: (args: MonitorArgs<DragType>) => CleanupFn;
+};

package/dist/types-ts4.0/util/add-attribute.d.ts

@@ -0,0 +1,5 @@
+import { CleanupFn } from '../internal-types';
+export declare function addAttribute(element: Element, { attribute, value }: {
+    attribute: string;
+    value: string;
+}): CleanupFn;

package/dist/types-ts4.0/util/combine.d.ts

@@ -0,0 +1,3 @@
+import { CleanupFn } from '../internal-types';
+/** Create a new combined function that will call all the provided functions */
+export declare function combine(...fns: CleanupFn[]): CleanupFn;

package/dist/types-ts4.0/util/disable-native-drag-preview.d.ts

@@ -0,0 +1,3 @@
+export declare function disableNativeDragPreview({ nativeSetDragImage, }: {
+    nativeSetDragImage: DataTransfer['setDragImage'] | null;
+}): void;

package/dist/types-ts4.0/util/entering-and-leaving-the-window.d.ts

@@ -0,0 +1,6 @@
+export declare function isEnteringWindow({ dragEnter, }: {
+    dragEnter: DragEvent;
+}): boolean;
+export declare function isLeavingWindow({ dragLeave, }: {
+    dragLeave: DragEvent;
+}): boolean;

package/dist/types-ts4.0/util/fix-post-drag-pointer-bug.d.ts

@@ -0,0 +1,14 @@
+import type { DragLocation } from '../internal-types';
+/** 🔥🤮 Fix (Chrome, Safari and Firefox) bug where the element under where the user started dragging
+ * (on the viewport) is entered into by the browser after a drag finishes ("drop" or "dragend")
+ *
+ * @description
+ *
+ * Block pointer events on all elements except for the specific element that pointer is currently over
+ *
+ * - [Visual explanation of bug](https://twitter.com/alexandereardon/status/1633614212873465856)
+ * - [Chrome bug](https://bugs.chromium.org/p/chromium/issues/detail?id=410328)
+ */
+export declare function fixPostDragPointerBug({ current }: {
+    current: DragLocation;
+}): void;

package/dist/types-ts4.0/util/get-input.d.ts

@@ -0,0 +1,2 @@
+import { Input } from '../internal-types';
+export declare function getInput(event: DragEvent): Input;

package/dist/types-ts4.0/util/once.d.ts

@@ -0,0 +1,2 @@
+/** Provide a function that you only ever want to be called a single time */
+export declare function once<TFunc extends (...args: any[]) => any>(fn: TFunc): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;

package/dist/types-ts4.0/util/reorder.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reorder a provided `list`
+ * Returns a new array and does not modify the original array
+ */
+export declare function reorder<Value>({ list, startIndex, finishIndex, }: {
+    list: Value[];
+    startIndex: number;
+    finishIndex: number;
+}): Value[];

package/dist/types-ts4.0/util/scroll-just-enough-into-view.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Scroll an `element` just enough into view so that the element becomes totally visible.
+ * If the element is already totally visible then no scrolling will occur.
+ */
+export declare function scrollJustEnoughIntoView({ element, }: {
+    element: Element;
+}): void;

package/dist/types-ts4.0/util/set-custom-native-drag-preview.d.ts

@@ -0,0 +1,52 @@
+import { ElementEventPayloadMap } from '../adapter/element-adapter';
+/** A function to remove the element that has been added to the `container`.
+ * @example () => ReactDOM.unmountComponentAtNode(container)
+ */
+declare type CleanupFn = () => void;
+/** A function that will render a preview element into a `container` `HTMLElement` */
+declare type RenderFn = ({ container, }: {
+    /** The `HTMLElement` that you need to render your preview element into.
+    `container` will be appended to the `document.body` and will be removed
+    after your `CleanupFn` is called
+    */
+    container: HTMLElement;
+}) => CleanupFn | void;
+/** Any valid CSS string value
+ * @example `calc(var(--grid) * 2)
+ */
+declare type CSSValue = string;
+/**
+ * Where to place the custom drag preview
+ *
+ * `type: 'center'`: Place the center of the drag preview user the users pointer
+ *
+ * `type: 'offset-from-pointer'`: Shift the drag preview away from the users pointer
+ */
+declare type Placement = {
+    type: 'center';
+} | {
+    type: 'offset-from-pointer';
+    x: CSSValue;
+    y: CSSValue;
+};
+/** This function provides the ability to mount an element for it to be used as the native drag preview
+ *
+ * @example
+ * draggable({
+ *  onGenerateDragPreview: ({ nativeSetDragImage }) => {
+ *    setCustomNativeDragPreview({
+ *      render: ({ container }) => {
+ *        ReactDOM.render(<Preview item={item} />, container);
+ *        return () => ReactDOM.unmountComponentAtNode(container);
+ *      },
+ *      nativeSetDragImage,
+ *    });
+ *    },
+ * });
+ */
+export declare function setCustomNativeDragPreview({ render, nativeSetDragImage, placement, }: {
+    placement?: Placement;
+    render: RenderFn;
+    nativeSetDragImage: ElementEventPayloadMap['onGenerateDragPreview']['nativeSetDragImage'];
+}): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/pragmatic-drag-and-drop",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "The core Pragmatic drag and drop framework, optimized for performance.",
   "repository": "https://bitbucket.org/atlassian/atlassian-frontend-mirror",
   "author": "Atlassian Pty Ltd",
@@ -82,6 +82,6 @@
       ]
     }
   },
-  "homepage": "https://atlassian.design/components/drag-and-drop/",
+  "homepage": "https://atlassian.design/components/pragmatic-drag-and-drop/",
   "prettier": "@atlassian/atlassian-frontend-prettier-config-1.0.0"
 }