@dnd-kit/abstract 0.0.1

package/index.cjs

@@ -0,0 +1,928 @@
+'use strict';
+
+var state = require('@dnd-kit/state');
+var geometry = require('@dnd-kit/geometry');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// src/core/plugins/utilities.ts
+function configure(plugin, options) {
+  return {
+    plugin,
+    options
+  };
+}
+function configurator(plugin) {
+  return (options) => {
+    return configure(plugin, options);
+  };
+}
+function descriptor(plugin) {
+  if (typeof plugin === "function") {
+    return {
+      plugin,
+      options: void 0
+    };
+  }
+  return plugin;
+}
+
+// src/core/plugins/plugin.ts
+var Plugin = class {
+  constructor(manager, options) {
+    this.manager = manager;
+    this.options = options;
+  }
+  disabled = false;
+  /**
+   * Enable a disabled plugin instance.
+   * Triggers effects.
+   */
+  enable() {
+    this.disabled = false;
+  }
+  /**
+   * Disable an enabled plugin instance.
+   * Triggers effects.
+   */
+  disable() {
+    this.disabled = true;
+  }
+  /**
+   * Whether the plugin instance is disabled.
+   * Does not trigger effects when accessed.
+   */
+  isDisabled() {
+    return state.untracked(() => {
+      return this.disabled;
+    });
+  }
+  /**
+   * Configure a plugin instance with new options.
+   */
+  configure(options) {
+    this.options = options;
+  }
+  /**
+   * Destroy a plugin instance.
+   */
+  destroy() {
+  }
+  /**
+   * Configure a plugin constructor with options.
+   * This method is used to configure the options that the
+   * plugin constructor will use to create plugin instances.
+   */
+  static configure(options) {
+    return configure(this, options);
+  }
+};
+__decorateClass([
+  state.reactive
+], Plugin.prototype, "disabled", 2);
+var CorePlugin = class extends Plugin {
+};
+
+// src/core/plugins/registry.ts
+var PluginRegistry = class {
+  constructor(manager) {
+    this.manager = manager;
+  }
+  instances = /* @__PURE__ */ new Map();
+  get values() {
+    return Array.from(this.instances.values());
+  }
+  #previousValues = [];
+  set values(entries) {
+    const descriptos = entries.map(descriptor);
+    const constructors = descriptos.map(({ plugin }) => plugin);
+    for (const plugin of this.#previousValues) {
+      if (!constructors.includes(plugin)) {
+        if (plugin.prototype instanceof CorePlugin) {
+          continue;
+        }
+        this.unregister(plugin);
+      }
+    }
+    for (const { plugin, options } of descriptos) {
+      this.register(plugin, options);
+    }
+    this.#previousValues = constructors;
+  }
+  get(plugin) {
+    const instance = this.instances.get(plugin);
+    return instance;
+  }
+  register(plugin, options) {
+    const existingInstance = this.instances.get(plugin);
+    if (existingInstance) {
+      return existingInstance;
+    }
+    const instance = new plugin(this.manager, options);
+    this.instances.set(plugin, instance);
+    return instance;
+  }
+  unregister(plugin) {
+    const instance = this.instances.get(plugin);
+    if (instance) {
+      instance.destroy();
+      this.instances.delete(plugin);
+    }
+  }
+  destroy() {
+    for (const plugin of this.instances.values()) {
+      plugin.destroy();
+    }
+    this.instances.clear();
+  }
+};
+
+// src/core/collision/utilities.ts
+function sortCollisions(a, b) {
+  if (a.priority === b.priority) {
+    return b.value - a.value;
+  }
+  return b.priority - a.priority;
+}
+
+// src/core/collision/observer.ts
+var DEFAULT_VALUE = [];
+var CollisionObserver = class extends Plugin {
+  constructor(manager) {
+    super(manager);
+    this.computeCollisions = this.computeCollisions.bind(this);
+    this.#collisions = state.computed(this.computeCollisions, state.deepEqual);
+    this.destroy = state.effect(() => {
+      const { dragOperation } = this.manager;
+      if (dragOperation.status.initialized) {
+        this.forceUpdate();
+      }
+    });
+  }
+  forceUpdateCount = state.signal(0);
+  forceUpdate(refresh = true) {
+    state.untracked(() => {
+      const { source } = this.manager.dragOperation;
+      state.batch(() => {
+        if (refresh) {
+          for (const droppable of this.manager.registry.droppables) {
+            if (source && !droppable.accepts(source)) {
+              continue;
+            }
+            droppable.refreshShape();
+          }
+        }
+        this.forceUpdateCount.value++;
+      });
+    });
+  }
+  computeCollisions(entries, collisionDetector) {
+    const { registry, dragOperation } = this.manager;
+    const { source, shape, status } = dragOperation;
+    if (!status.initialized || !shape) {
+      return DEFAULT_VALUE;
+    }
+    const collisions = [];
+    this.forceUpdateCount.value;
+    for (const entry of entries ?? registry.droppables) {
+      if (entry.disabled) {
+        continue;
+      }
+      if (source && !entry.accepts(source)) {
+        continue;
+      }
+      const detectCollision = collisionDetector ?? entry.collisionDetector;
+      if (!detectCollision) {
+        continue;
+      }
+      const collision = state.untracked(
+        () => detectCollision({
+          droppable: entry,
+          dragOperation
+        })
+      );
+      if (collision) {
+        if (entry.collisionPriority != null) {
+          collision.priority = entry.collisionPriority;
+        }
+        collisions.push(collision);
+      }
+    }
+    collisions.sort(sortCollisions);
+    return collisions;
+  }
+  get collisions() {
+    return this.#collisions.value;
+  }
+  #collisions;
+};
+
+// src/core/manager/events.ts
+var Monitor = class {
+  registry = /* @__PURE__ */ new Map();
+  addEventListener(name, handler) {
+    const { registry } = this;
+    const listeners = new Set(registry.get(name));
+    listeners.add(handler);
+    registry.set(name, listeners);
+    return () => this.removeEventListener(name, handler);
+  }
+  removeEventListener(name, handler) {
+    const { registry } = this;
+    const listeners = new Set(registry.get(name));
+    listeners.delete(handler);
+    registry.set(name, listeners);
+  }
+  dispatch(name, ...args) {
+    const { registry } = this;
+    const listeners = registry.get(name);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(...args);
+    }
+  }
+};
+var DragDropMonitor = class extends Monitor {
+  constructor(manager) {
+    super();
+    this.manager = manager;
+  }
+  dispatch(type, event) {
+    const args = [event, this.manager];
+    super.dispatch(type, ...args);
+  }
+};
+function defaultPreventable(event, cancelable = true) {
+  let defaultPrevented = false;
+  return {
+    ...event,
+    cancelable,
+    get defaultPrevented() {
+      return defaultPrevented;
+    },
+    preventDefault() {
+      if (!cancelable) {
+        return;
+      }
+      defaultPrevented = true;
+    }
+  };
+}
+
+// src/core/collision/notifier.ts
+var CollisionNotifier = class extends CorePlugin {
+  constructor(manager) {
+    super(manager);
+    this.destroy = state.effect(() => {
+      const { collisionObserver, monitor } = manager;
+      const { collisions } = collisionObserver;
+      if (collisionObserver.isDisabled()) {
+        return;
+      }
+      const event = defaultPreventable({
+        collisions
+      });
+      monitor.dispatch("collision", event);
+      if (event.defaultPrevented) {
+        return;
+      }
+      const [firstCollision] = collisions;
+      state.untracked(() => {
+        if (firstCollision?.id !== manager.dragOperation.target?.id) {
+          collisionObserver.disable();
+          manager.actions.setDropTarget(firstCollision?.id).then(() => {
+            collisionObserver.enable();
+          });
+        }
+      });
+    });
+  }
+};
+
+// src/core/collision/types.ts
+var CollisionPriority = /* @__PURE__ */ ((CollisionPriority2) => {
+  CollisionPriority2[CollisionPriority2["Lowest"] = 0] = "Lowest";
+  CollisionPriority2[CollisionPriority2["Low"] = 1] = "Low";
+  CollisionPriority2[CollisionPriority2["Normal"] = 2] = "Normal";
+  CollisionPriority2[CollisionPriority2["High"] = 3] = "High";
+  CollisionPriority2[CollisionPriority2["Highest"] = 4] = "Highest";
+  return CollisionPriority2;
+})(CollisionPriority || {});
+var Entity = class {
+  /**
+   * Creates a new instance of the `Entity` class.
+   *
+   * @param input - An object containing the initial properties of the entity.
+   * @param manager - The manager that controls the drag and drop operations.
+   */
+  constructor(input, manager) {
+    this.manager = manager;
+    const { effects: getInputEffects, id, data = null, disabled = false } = input;
+    this.id = id;
+    this.data = data;
+    this.disabled = disabled;
+    queueMicrotask(() => {
+      const inputEffects = getInputEffects?.(this) ?? [];
+      this.destroy = state.effects(
+        () => {
+          manager.registry.register(this);
+          return () => manager.registry.unregister(this);
+        },
+        ...inputEffects
+      );
+    });
+  }
+  id;
+  data;
+  disabled;
+  /**
+   * A method that cleans up the entity when it is no longer needed.
+   * @returns void
+   */
+  destroy() {
+  }
+};
+__decorateClass([
+  state.reactive
+], Entity.prototype, "id", 2);
+__decorateClass([
+  state.reactive
+], Entity.prototype, "data", 2);
+__decorateClass([
+  state.reactive
+], Entity.prototype, "disabled", 2);
+var EntityRegistry = class {
+  map = state.signal(/* @__PURE__ */ new Map());
+  /**
+   * Iterator for the EntityRegistry class.
+   * @returns An iterator for the values in the map.
+   */
+  [Symbol.iterator]() {
+    return this.map.peek().values();
+  }
+  get value() {
+    return this.map.value.values();
+  }
+  /**
+   * Checks if a entity with the given identifier exists in the registry.
+   * @param identifier - The unique identifier of the entity.
+   * @returns True if the entity exists, false otherwise.
+   */
+  has(identifier) {
+    return this.map.value.has(identifier);
+  }
+  /**
+   * Retrieves a entity from the registry using its identifier.
+   * @param identifier - The unique identifier of the entity.
+   * @returns The entity if it exists, undefined otherwise.
+   */
+  get(identifier) {
+    return this.map.value.get(identifier);
+  }
+  /**
+   * Registers a entity in the registry.
+   * @param key - The unique identifier of the entity.
+   * @param value - The entity to register.
+   * @returns A function that unregisters the entity.
+   */
+  register = (key, value) => {
+    const current = this.map.peek();
+    if (current.get(key) === value) {
+      return;
+    }
+    const updatedMap = new Map(current);
+    updatedMap.set(key, value);
+    this.map.value = updatedMap;
+    return () => this.unregister(key, value);
+  };
+  /**
+   * Unregisters an entity from the registry.
+   * @param key - The unique identifier of the entity.
+   * @param value - The entity instance to unregister.
+   */
+  unregister = (key, value) => {
+    const current = this.map.peek();
+    if (current.get(key) !== value) {
+      return;
+    }
+    const updatedMap = new Map(current);
+    updatedMap.delete(key);
+    this.map.value = updatedMap;
+  };
+  /**
+   * Destroys all entries in the registry and clears the registry.
+   */
+  destroy() {
+    for (const entry of this) {
+      entry.destroy();
+    }
+    this.map.value = /* @__PURE__ */ new Map();
+  }
+};
+var Draggable = class extends Entity {
+  constructor({ modifiers, type, ...input }, manager) {
+    super(input, manager);
+    this.manager = manager;
+    this.type = type;
+    if (modifiers?.length) {
+      this.modifiers = modifiers.map((modifier) => {
+        const { plugin, options } = descriptor(modifier);
+        return new plugin(manager, options);
+      });
+    }
+  }
+  modifiers;
+  type;
+  get isDragSource() {
+    const { dragOperation } = this.manager;
+    return dragOperation.source?.id === this.id;
+  }
+};
+__decorateClass([
+  state.reactive
+], Draggable.prototype, "type", 2);
+__decorateClass([
+  state.derived
+], Draggable.prototype, "isDragSource", 1);
+var Droppable = class extends Entity {
+  constructor({
+    accept,
+    collisionDetector,
+    collisionPriority = 2 /* Normal */,
+    type,
+    ...input
+  }, manager) {
+    super(input, manager);
+    this.manager = manager;
+    this.accept = accept;
+    this.collisionDetector = collisionDetector;
+    this.collisionPriority = collisionPriority;
+    this.type = type;
+  }
+  accept;
+  type;
+  /**
+   * Checks whether or not the droppable accepts a given draggable.
+   *
+   * @param {Draggable} draggable
+   * @returns {boolean}
+   */
+  accepts(draggable) {
+    const { accept } = this;
+    if (!accept) {
+      return true;
+    }
+    if (!draggable.type) {
+      return false;
+    }
+    if (Array.isArray(accept)) {
+      return accept.includes(draggable.type);
+    }
+    if (typeof accept === "function") {
+      return accept(draggable);
+    }
+    return draggable.type === accept;
+  }
+  collisionDetector;
+  collisionPriority;
+  shape;
+  get isDropTarget() {
+    return this.manager.dragOperation.target?.id === this.id;
+  }
+  refreshShape() {
+  }
+};
+__decorateClass([
+  state.reactive
+], Droppable.prototype, "accept", 2);
+__decorateClass([
+  state.reactive
+], Droppable.prototype, "type", 2);
+__decorateClass([
+  state.reactive
+], Droppable.prototype, "collisionDetector", 2);
+__decorateClass([
+  state.reactive
+], Droppable.prototype, "collisionPriority", 2);
+__decorateClass([
+  state.reactive
+], Droppable.prototype, "shape", 2);
+__decorateClass([
+  state.derived
+], Droppable.prototype, "isDropTarget", 1);
+
+// src/core/sensors/sensor.ts
+var Sensor = class extends Plugin {
+  constructor(manager, options) {
+    super(manager, options);
+    this.manager = manager;
+    this.options = options;
+  }
+};
+
+// src/core/modifiers/modifier.ts
+var Modifier = class extends Plugin {
+  constructor(manager, options) {
+    super(manager, options);
+    this.manager = manager;
+    this.options = options;
+  }
+  apply(operation) {
+    return operation.transform;
+  }
+};
+
+// src/core/manager/registry.ts
+var DragDropRegistry = class {
+  constructor(manager) {
+    this.plugins = new PluginRegistry(manager);
+    this.sensors = new PluginRegistry(manager);
+    this.modifiers = new PluginRegistry(manager);
+  }
+  draggables = new EntityRegistry();
+  droppables = new EntityRegistry();
+  plugins;
+  sensors;
+  modifiers;
+  register(input, options) {
+    if (input instanceof Draggable) {
+      return this.draggables.register(input.id, input);
+    }
+    if (input instanceof Droppable) {
+      return this.droppables.register(input.id, input);
+    }
+    if (input.prototype instanceof Modifier) {
+      return this.modifiers.register(input, options);
+    }
+    if (input.prototype instanceof Sensor) {
+      return this.sensors.register(input, options);
+    }
+    if (input.prototype instanceof Plugin) {
+      return this.plugins.register(input, options);
+    }
+    throw new Error("Invalid instance type");
+  }
+  unregister(input) {
+    if (input instanceof Entity) {
+      if (input instanceof Draggable) {
+        return this.draggables.unregister(input.id, input);
+      }
+      if (input instanceof Droppable) {
+        return this.droppables.unregister(input.id, input);
+      }
+      return () => {
+      };
+    }
+    if (input.prototype instanceof Modifier) {
+      return this.modifiers.unregister(input);
+    }
+    if (input.prototype instanceof Sensor) {
+      return this.sensors.unregister(input);
+    }
+    if (input.prototype instanceof Plugin) {
+      return this.plugins.unregister(input);
+    }
+    throw new Error("Invalid instance type");
+  }
+  destroy() {
+    this.draggables.destroy();
+    this.droppables.destroy();
+    this.plugins.destroy();
+    this.sensors.destroy();
+    this.modifiers.destroy();
+  }
+};
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["Idle"] = "idle";
+  Status2["Initializing"] = "initializing";
+  Status2["Dragging"] = "dragging";
+  Status2["Dropping"] = "dropping";
+  return Status2;
+})(Status || {});
+function DragOperationManager(manager) {
+  const {
+    registry: { draggables, droppables },
+    monitor
+  } = manager;
+  const status = state.signal("idle" /* Idle */);
+  const shape = {
+    initial: state.signal(null),
+    current: state.signal(null)
+  };
+  const canceled = state.signal(false);
+  const position = new geometry.Position({ x: 0, y: 0 });
+  const activatorEvent = state.signal(null);
+  const sourceIdentifier = state.signal(null);
+  const targetIdentifier = state.signal(null);
+  const dragging = state.computed(() => status.value === "dragging" /* Dragging */);
+  const initialized = state.computed(() => status.value !== "idle" /* Idle */);
+  const initializing = state.computed(() => status.value === "initializing" /* Initializing */);
+  const idle = state.computed(() => status.value === "idle" /* Idle */);
+  const dropping = state.computed(() => status.value === "dropping" /* Dropping */);
+  let previousSource;
+  const source = state.computed(() => {
+    const identifier = sourceIdentifier.value;
+    if (identifier == null)
+      return null;
+    const value = draggables.get(identifier);
+    if (value) {
+      previousSource = value;
+    }
+    return value ?? previousSource ?? null;
+  });
+  const target = state.computed(() => {
+    const identifier = targetIdentifier.value;
+    return identifier != null ? droppables.get(identifier) ?? null : null;
+  });
+  const transform = state.computed(() => {
+    const { x, y } = position.delta;
+    const modifiers = source?.value?.modifiers ?? manager.modifiers;
+    let transform2 = { x, y };
+    const initialShape = shape.initial.peek();
+    const currentShape = shape.current.peek();
+    const operation2 = {
+      activatorEvent: activatorEvent.peek(),
+      canceled: canceled.peek(),
+      source: source.peek(),
+      target: target.peek(),
+      status: {
+        current: status.peek(),
+        idle: idle.peek(),
+        initializing: initializing.peek(),
+        initialized: initialized.peek(),
+        dragging: dragging.peek(),
+        dropping: dropping.peek()
+      },
+      shape: initialShape && currentShape ? { initial: initialShape, current: currentShape } : null,
+      position
+    };
+    for (const modifier of modifiers) {
+      transform2 = modifier.apply({ ...operation2, transform: transform2 });
+    }
+    return transform2;
+  });
+  const operation = {
+    get activatorEvent() {
+      return activatorEvent.value;
+    },
+    get canceled() {
+      return canceled.value;
+    },
+    get source() {
+      return source.value;
+    },
+    get target() {
+      return target.value;
+    },
+    status: {
+      get current() {
+        return status.value;
+      },
+      get idle() {
+        return idle.value;
+      },
+      get initializing() {
+        return initializing.value;
+      },
+      get initialized() {
+        return initialized.value;
+      },
+      get dragging() {
+        return dragging.value;
+      },
+      get dropping() {
+        return dropping.value;
+      }
+    },
+    get shape() {
+      const initial = shape.initial.value;
+      const current = shape.current.value;
+      return initial && current ? { initial, current } : null;
+    },
+    set shape(value) {
+      if (value && shape.current.peek()?.equals(value)) {
+        return;
+      }
+      const initial = shape.initial.peek();
+      if (!initial) {
+        shape.initial.value = value;
+      }
+      shape.current.value = value;
+    },
+    get transform() {
+      return transform.value;
+    },
+    position
+  };
+  const reset = () => {
+    state.batch(() => {
+      status.value = "idle" /* Idle */;
+      sourceIdentifier.value = null;
+      targetIdentifier.value = null;
+      shape.current.value = null;
+      shape.initial.value = null;
+      position.reset({ x: 0, y: 0 });
+    });
+  };
+  return {
+    operation,
+    actions: {
+      setDragSource(identifier) {
+        sourceIdentifier.value = identifier;
+      },
+      setDropTarget(identifier) {
+        const id = identifier ?? null;
+        if (targetIdentifier.peek() === id) {
+          return Promise.resolve();
+        }
+        targetIdentifier.value = id;
+        monitor.dispatch(
+          "dragover",
+          defaultPreventable({
+            operation: snapshot(operation)
+          })
+        );
+        return manager.renderer.rendering;
+      },
+      start({ event, coordinates }) {
+        state.batch(() => {
+          canceled.value = false;
+          activatorEvent.value = event;
+          position.reset(coordinates);
+        });
+        const beforeStartEvent = defaultPreventable({
+          operation: snapshot(operation)
+        });
+        monitor.dispatch("beforedragstart", beforeStartEvent);
+        manager.renderer.rendering.then(() => {
+          if (beforeStartEvent.defaultPrevented) {
+            reset();
+            return;
+          }
+          status.value = "initializing" /* Initializing */;
+          requestAnimationFrame(() => {
+            status.value = "dragging" /* Dragging */;
+            monitor.dispatch("dragstart", {
+              operation: snapshot(operation),
+              cancelable: false
+            });
+          });
+        });
+      },
+      move({
+        by,
+        to,
+        cancelable = true
+      }) {
+        if (!dragging.peek()) {
+          return;
+        }
+        const event = defaultPreventable(
+          {
+            operation: snapshot(operation),
+            by,
+            to
+          },
+          cancelable
+        );
+        monitor.dispatch("dragmove", event);
+        queueMicrotask(() => {
+          if (event.defaultPrevented) {
+            return;
+          }
+          const coordinates = to ?? {
+            x: position.current.x + by.x,
+            y: position.current.y + by.y
+          };
+          position.update(coordinates);
+        });
+      },
+      stop({ canceled: eventCanceled = false } = {}) {
+        let promise;
+        const suspend = () => {
+          const output = {
+            resume: () => {
+            },
+            abort: () => {
+            }
+          };
+          promise = new Promise((resolve, reject) => {
+            output.resume = resolve;
+            output.abort = reject;
+          });
+          return output;
+        };
+        const end = () => {
+          manager.renderer.rendering.then(() => {
+            status.value = "dropping" /* Dropping */;
+            manager.renderer.rendering.then(reset);
+          });
+        };
+        canceled.value = eventCanceled;
+        monitor.dispatch("dragend", {
+          operation: snapshot(operation),
+          canceled: eventCanceled,
+          suspend
+        });
+        if (promise) {
+          promise.then(end).catch(reset);
+        } else {
+          end();
+        }
+      }
+    }
+  };
+}
+function snapshot(obj) {
+  return {
+    ...obj
+  };
+}
+
+// src/core/manager/renderer.ts
+var defaultRenderer = {
+  get rendering() {
+    return Promise.resolve();
+  }
+};
+
+// src/core/manager/manager.ts
+var DragDropManager = class {
+  actions;
+  collisionObserver;
+  dragOperation;
+  monitor;
+  registry;
+  renderer;
+  constructor(config) {
+    const {
+      plugins = [],
+      sensors = [],
+      modifiers = [],
+      renderer = defaultRenderer
+    } = config ?? {};
+    const monitor = new DragDropMonitor(this);
+    const registry = new DragDropRegistry(this);
+    this.registry = registry;
+    this.monitor = monitor;
+    this.renderer = renderer;
+    const { actions, operation } = DragOperationManager(this);
+    this.actions = actions;
+    this.dragOperation = operation;
+    this.collisionObserver = new CollisionObserver(this);
+    this.plugins = [CollisionNotifier, ...plugins];
+    this.modifiers = modifiers;
+    this.sensors = sensors;
+  }
+  get plugins() {
+    return this.registry.plugins.values;
+  }
+  set plugins(plugins) {
+    this.registry.plugins.values = plugins;
+  }
+  get modifiers() {
+    return this.registry.modifiers.values;
+  }
+  set modifiers(modifiers) {
+    this.registry.modifiers.values = modifiers;
+  }
+  get sensors() {
+    return this.registry.sensors.values;
+  }
+  set sensors(sensors) {
+    this.registry.sensors.values = sensors;
+  }
+  destroy() {
+    this.registry.destroy();
+    this.collisionObserver.destroy();
+  }
+};
+
+exports.CollisionPriority = CollisionPriority;
+exports.CorePlugin = CorePlugin;
+exports.DragDropManager = DragDropManager;
+exports.DragOperationStatus = Status;
+exports.Draggable = Draggable;
+exports.Droppable = Droppable;
+exports.Modifier = Modifier;
+exports.Plugin = Plugin;
+exports.PluginRegistry = PluginRegistry;
+exports.Sensor = Sensor;
+exports.configurator = configurator;
+exports.configure = configure;
+exports.descriptor = descriptor;
+exports.sortCollisions = sortCollisions;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map