@dnd-kit/abstract 0.0.3 → 0.0.4-beta-20240621131401

package/index.js

@@ -1,17 +1,86 @@
-import { untracked, reactive, derived, computed, deepEqual, effect, signal, batch, effects } from '@dnd-kit/state';
+import { untracked, reactive, signal, computed, deepEqual, effect, batch, derived, effects } from '@dnd-kit/state';
 import { Position } from '@dnd-kit/geometry';
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 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;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __decoratorStart = (base) => {
+  var _a;
+  return [, , , __create((_a = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/core/plugins/utilities.ts
 function configure(plugin, options) {
@@ -36,12 +105,14 @@ function descriptor(plugin) {
 }
 
 // src/core/plugins/plugin.ts
+var _disabled_dec, _init, _disabled;
+_disabled_dec = [reactive];
 var Plugin = class {
   constructor(manager, options) {
     this.manager = manager;
     this.options = options;
+    __privateAdd(this, _disabled, __runInitializers(_init, 8, this, false)), __runInitializers(_init, 11, this);
   }
-  disabled = false;
   /**
    * Enable a disabled plugin instance.
    * Triggers effects.
@@ -85,26 +156,28 @@ var Plugin = class {
     return configure(this, options);
   }
 };
-__decorateClass([
-  reactive
-], Plugin.prototype, "disabled", 2);
+_init = __decoratorStart(null);
+_disabled = new WeakMap();
+__decorateElement(_init, 4, "disabled", _disabled_dec, Plugin, _disabled);
+__decoratorMetadata(_init, Plugin);
 var CorePlugin = class extends Plugin {
 };
 
 // src/core/plugins/registry.ts
+var _previousValues;
 var PluginRegistry = class {
   constructor(manager) {
     this.manager = manager;
+    this.instances = /* @__PURE__ */ new Map();
+    __privateAdd(this, _previousValues, []);
   }
-  instances = /* @__PURE__ */ new Map();
   get values() {
     return Array.from(this.instances.values());
   }
-  #previousValues = [];
   set values(entries) {
     const descriptors = entries.map(descriptor);
     const constructors = descriptors.map(({ plugin }) => plugin);
-    for (const plugin of this.#previousValues) {
+    for (const plugin of __privateGet(this, _previousValues)) {
       if (!constructors.includes(plugin)) {
         if (plugin.prototype instanceof CorePlugin) {
           continue;
@@ -115,7 +188,7 @@ var PluginRegistry = class {
     for (const { plugin, options } of descriptors) {
       this.register(plugin, options);
     }
-    this.#previousValues = constructors;
+    __privateSet(this, _previousValues, constructors);
   }
   get(plugin) {
     const instance = this.instances.get(plugin);
@@ -144,6 +217,7 @@ var PluginRegistry = class {
     this.instances.clear();
   }
 };
+_previousValues = new WeakMap();
 
 // src/core/collision/utilities.ts
 function sortCollisions(a, b) {
@@ -155,11 +229,14 @@ function sortCollisions(a, b) {
 
 // src/core/collision/observer.ts
 var DEFAULT_VALUE = [];
+var _collisions;
 var CollisionObserver = class extends Plugin {
   constructor(manager) {
     super(manager);
+    this.forceUpdateCount = signal(0);
+    __privateAdd(this, _collisions);
     this.computeCollisions = this.computeCollisions.bind(this);
-    this.#collisions = computed(this.computeCollisions, deepEqual);
+    __privateSet(this, _collisions, computed(this.computeCollisions, deepEqual));
     this.destroy = effect(() => {
       const { dragOperation } = this.manager;
       if (dragOperation.status.initialized) {
@@ -167,7 +244,6 @@ var CollisionObserver = class extends Plugin {
       }
     });
   }
-  forceUpdateCount = signal(0);
   forceUpdate(refresh = true) {
     untracked(() => {
       const { source } = this.manager.dragOperation;
@@ -192,14 +268,14 @@ var CollisionObserver = class extends Plugin {
     }
     const collisions = [];
     this.forceUpdateCount.value;
-    for (const entry of entries ?? registry.droppables) {
+    for (const entry of entries != null ? entries : registry.droppables) {
       if (entry.disabled) {
         continue;
       }
       if (source && !entry.accepts(source)) {
         continue;
       }
-      const detectCollision = collisionDetector ?? entry.collisionDetector;
+      const detectCollision = collisionDetector != null ? collisionDetector : entry.collisionDetector;
       if (!detectCollision) {
         continue;
       }
@@ -220,14 +296,16 @@ var CollisionObserver = class extends Plugin {
     return collisions;
   }
   get collisions() {
-    return this.#collisions.value;
+    return __privateGet(this, _collisions).value;
   }
-  #collisions;
 };
+_collisions = new WeakMap();
 
 // src/core/manager/events.ts
 var Monitor = class {
-  registry = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
   addEventListener(name, handler) {
     const { registry } = this;
     const listeners = new Set(registry.get(name));
@@ -264,8 +342,7 @@ var DragDropMonitor = class extends Monitor {
 };
 function defaultPreventable(event, cancelable = true) {
   let defaultPrevented = false;
-  return {
-    ...event,
+  return __spreadProps(__spreadValues({}, event), {
     cancelable,
     get defaultPrevented() {
       return defaultPrevented;
@@ -276,7 +353,7 @@ function defaultPreventable(event, cancelable = true) {
       }
       defaultPrevented = true;
     }
-  };
+  });
 }
 
 // src/core/collision/notifier.ts
@@ -298,9 +375,10 @@ var CollisionNotifier = class extends CorePlugin {
       }
       const [firstCollision] = collisions;
       untracked(() => {
-        if (firstCollision?.id !== manager.dragOperation.target?.id) {
+        var _a;
+        if ((firstCollision == null ? void 0 : firstCollision.id) !== ((_a = manager.dragOperation.target) == null ? void 0 : _a.id)) {
           collisionObserver.disable();
-          manager.actions.setDropTarget(firstCollision?.id).then(() => {
+          manager.actions.setDropTarget(firstCollision == null ? void 0 : firstCollision.id).then(() => {
             collisionObserver.enable();
           });
         }
@@ -321,6 +399,8 @@ var CollisionPriority = /* @__PURE__ */ ((CollisionPriority2) => {
 function getDefaultEffects() {
   return [];
 }
+var _disabled_dec2, _data_dec, _id_dec, _manager_dec, _init2, _manager, _id, _data, _disabled2;
+_manager_dec = [reactive], _id_dec = [reactive], _data_dec = [reactive], _disabled_dec2 = [reactive];
 var Entity = class {
   /**
    * Creates a new instance of the `Entity` class.
@@ -329,6 +409,10 @@ var Entity = class {
    * @param manager - The manager that controls the drag and drop operations.
    */
   constructor(input, manager) {
+    __privateAdd(this, _manager, __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
+    __privateAdd(this, _id, __runInitializers(_init2, 12, this)), __runInitializers(_init2, 15, this);
+    __privateAdd(this, _data, __runInitializers(_init2, 16, this)), __runInitializers(_init2, 19, this);
+    __privateAdd(this, _disabled2, __runInitializers(_init2, 20, this)), __runInitializers(_init2, 23, this);
     const {
       effects: getEffects = getDefaultEffects,
       id,
@@ -343,52 +427,82 @@ var Entity = class {
     this.disabled = disabled;
     this.effects = () => [
       () => {
+        const { id: _, manager: manager2 } = this;
         if (id === previousId) {
           return;
         }
-        manager.registry.register(this);
-        return () => manager.registry.unregister(this);
+        manager2 == null ? void 0 : manager2.registry.register(this);
+        return () => manager2 == null ? void 0 : manager2.registry.unregister(this);
       },
       ...getEffects()
     ];
     this.destroy = this.destroy.bind(this);
-    if (options?.register !== false) {
+    if ((options == null ? void 0 : options.register) !== false) {
       queueMicrotask(() => {
-        manager.registry.register(this);
+        var _a;
+        (_a = this.manager) == null ? void 0 : _a.registry.register(this);
       });
     }
   }
-  manager;
-  id;
-  data;
-  disabled;
-  /**
-   * An array of effects that are applied to the entity.
-   */
-  effects;
   /**
    * A method that cleans up the entity when it is no longer needed.
    * @returns void
    */
   destroy() {
-    this.manager.registry.unregister(this);
+    var _a;
+    (_a = this.manager) == null ? void 0 : _a.registry.unregister(this);
   }
 };
-__decorateClass([
-  reactive
-], Entity.prototype, "manager", 2);
-__decorateClass([
-  reactive
-], Entity.prototype, "id", 2);
-__decorateClass([
-  reactive
-], Entity.prototype, "data", 2);
-__decorateClass([
-  reactive
-], Entity.prototype, "disabled", 2);
+_init2 = __decoratorStart(null);
+_manager = new WeakMap();
+_id = new WeakMap();
+_data = new WeakMap();
+_disabled2 = new WeakMap();
+__decorateElement(_init2, 4, "manager", _manager_dec, Entity, _manager);
+__decorateElement(_init2, 4, "id", _id_dec, Entity, _id);
+__decorateElement(_init2, 4, "data", _data_dec, Entity, _data);
+__decorateElement(_init2, 4, "disabled", _disabled_dec2, Entity, _disabled2);
+__decoratorMetadata(_init2, Entity);
 var EntityRegistry = class {
-  map = signal(/* @__PURE__ */ new Map());
-  cleanupFunctions = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    this.map = signal(/* @__PURE__ */ new Map());
+    this.cleanupFunctions = /* @__PURE__ */ new WeakMap();
+    /**
+     * 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.
+     */
+    this.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;
+      const cleanup = effects(...value.effects());
+      this.cleanupFunctions.set(value, cleanup);
+      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.
+     */
+    this.unregister = (key, value) => {
+      const current = this.map.peek();
+      if (current.get(key) !== value) {
+        return;
+      }
+      const cleanup = this.cleanupFunctions.get(value);
+      cleanup == null ? void 0 : cleanup();
+      this.cleanupFunctions.delete(value);
+      const updatedMap = new Map(current);
+      updatedMap.delete(key);
+      this.map.value = updatedMap;
+    };
+  }
   /**
    * Iterator for the EntityRegistry class.
    * @returns An iterator for the values in the map.
@@ -415,106 +529,85 @@ var EntityRegistry = class {
   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;
-    const cleanup = effects(...value.effects());
-    this.cleanupFunctions.set(value, cleanup);
-    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 cleanup = this.cleanupFunctions.get(value);
-    cleanup?.();
-    this.cleanupFunctions.delete(value);
-    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) {
       const cleanup = this.cleanupFunctions.get(entry);
-      cleanup?.();
+      cleanup == null ? void 0 : cleanup();
       entry.destroy();
     }
     this.map.value = /* @__PURE__ */ new Map();
   }
 };
-var Draggable = class extends Entity {
-  constructor({ modifiers, type, sensors, ...input }, manager) {
+var _isDragSource_dec, _type_dec, _c, _modifiers, _init3, _type;
+var Draggable = class extends (_c = Entity, _type_dec = [reactive], _isDragSource_dec = [derived], _c) {
+  constructor(_a, manager) {
+    var _b = _a, { modifiers, type, sensors } = _b, input = __objRest(_b, ["modifiers", "type", "sensors"]);
     super(input, manager);
-    this.manager = manager;
+    __runInitializers(_init3, 5, this);
+    __privateAdd(this, _modifiers);
+    __privateAdd(this, _type, __runInitializers(_init3, 8, this)), __runInitializers(_init3, 11, this);
     this.type = type;
     this.sensors = sensors;
     this.modifiers = modifiers;
   }
-  sensors;
-  #modifiers;
   set modifiers(modifiers) {
-    this.#modifiers?.forEach((modifier) => modifier.destroy());
-    this.#modifiers = modifiers?.map((modifier) => {
+    var _a;
+    const { manager } = this;
+    (_a = __privateGet(this, _modifiers)) == null ? void 0 : _a.forEach((modifier) => modifier.destroy());
+    if (!manager) return;
+    __privateSet(this, _modifiers, modifiers == null ? void 0 : modifiers.map((modifier) => {
       const { plugin, options } = descriptor(modifier);
-      return new plugin(this.manager, options);
-    });
+      return new plugin(manager, options);
+    }));
   }
   get modifiers() {
-    return this.#modifiers;
+    return __privateGet(this, _modifiers);
   }
-  type;
   get isDragSource() {
-    const { dragOperation } = this.manager;
-    return dragOperation.source?.id === this.id;
+    var _a, _b;
+    return ((_b = (_a = this.manager) == null ? void 0 : _a.dragOperation.source) == null ? void 0 : _b.id) === this.id;
   }
   destroy() {
+    var _a;
     super.destroy();
-    this.modifiers?.forEach((modifier) => modifier.destroy());
+    (_a = this.modifiers) == null ? void 0 : _a.forEach((modifier) => modifier.destroy());
   }
 };
-__decorateClass([
-  reactive
-], Draggable.prototype, "type", 2);
-__decorateClass([
-  derived
-], Draggable.prototype, "isDragSource", 1);
-var Droppable = class extends Entity {
-  constructor({
-    accept,
-    collisionDetector,
-    collisionPriority = 2 /* Normal */,
-    type,
-    ...input
-  }, manager) {
+_init3 = __decoratorStart(_c);
+_modifiers = new WeakMap();
+_type = new WeakMap();
+__decorateElement(_init3, 4, "type", _type_dec, Draggable, _type);
+__decorateElement(_init3, 2, "isDragSource", _isDragSource_dec, Draggable);
+__decoratorMetadata(_init3, Draggable);
+var _isDropTarget_dec, _shape_dec, _collisionPriority_dec, _collisionDetector_dec, _type_dec2, _accept_dec, _c2, _init4, _accept, _type2, _collisionDetector, _collisionPriority, _shape;
+var Droppable = class extends (_c2 = Entity, _accept_dec = [reactive], _type_dec2 = [reactive], _collisionDetector_dec = [reactive], _collisionPriority_dec = [reactive], _shape_dec = [reactive], _isDropTarget_dec = [derived], _c2) {
+  constructor(_a, manager) {
+    var _b = _a, {
+      accept,
+      collisionDetector,
+      collisionPriority = 2 /* Normal */,
+      type
+    } = _b, input = __objRest(_b, [
+      "accept",
+      "collisionDetector",
+      "collisionPriority",
+      "type"
+    ]);
     super(input, manager);
-    this.manager = manager;
+    __runInitializers(_init4, 5, this);
+    __privateAdd(this, _accept, __runInitializers(_init4, 8, this)), __runInitializers(_init4, 11, this);
+    __privateAdd(this, _type2, __runInitializers(_init4, 12, this)), __runInitializers(_init4, 15, this);
+    __privateAdd(this, _collisionDetector, __runInitializers(_init4, 16, this)), __runInitializers(_init4, 19, this);
+    __privateAdd(this, _collisionPriority, __runInitializers(_init4, 20, this)), __runInitializers(_init4, 23, this);
+    __privateAdd(this, _shape, __runInitializers(_init4, 24, this)), __runInitializers(_init4, 27, this);
     this.accept = accept;
     this.collisionDetector = collisionDetector;
     this.collisionPriority = collisionPriority;
     this.type = type;
   }
-  accept;
-  type;
   /**
    * Checks whether or not the droppable accepts a given draggable.
    *
@@ -537,33 +630,26 @@ var Droppable = class extends Entity {
     }
     return draggable.type === accept;
   }
-  collisionDetector;
-  collisionPriority;
-  shape;
   get isDropTarget() {
-    return this.manager.dragOperation.target?.id === this.id;
+    var _a, _b;
+    return ((_b = (_a = this.manager) == null ? void 0 : _a.dragOperation.target) == null ? void 0 : _b.id) === this.id;
   }
   refreshShape() {
   }
 };
-__decorateClass([
-  reactive
-], Droppable.prototype, "accept", 2);
-__decorateClass([
-  reactive
-], Droppable.prototype, "type", 2);
-__decorateClass([
-  reactive
-], Droppable.prototype, "collisionDetector", 2);
-__decorateClass([
-  reactive
-], Droppable.prototype, "collisionPriority", 2);
-__decorateClass([
-  reactive
-], Droppable.prototype, "shape", 2);
-__decorateClass([
-  derived
-], Droppable.prototype, "isDropTarget", 1);
+_init4 = __decoratorStart(_c2);
+_accept = new WeakMap();
+_type2 = new WeakMap();
+_collisionDetector = new WeakMap();
+_collisionPriority = new WeakMap();
+_shape = new WeakMap();
+__decorateElement(_init4, 4, "accept", _accept_dec, Droppable, _accept);
+__decorateElement(_init4, 4, "type", _type_dec2, Droppable, _type2);
+__decorateElement(_init4, 4, "collisionDetector", _collisionDetector_dec, Droppable, _collisionDetector);
+__decorateElement(_init4, 4, "collisionPriority", _collisionPriority_dec, Droppable, _collisionPriority);
+__decorateElement(_init4, 4, "shape", _shape_dec, Droppable, _shape);
+__decorateElement(_init4, 2, "isDropTarget", _isDropTarget_dec, Droppable);
+__decoratorMetadata(_init4, Droppable);
 
 // src/core/sensors/sensor.ts
 var Sensor = class extends Plugin {
@@ -589,15 +675,12 @@ var Modifier = class extends Plugin {
 // src/core/manager/registry.ts
 var DragDropRegistry = class {
   constructor(manager) {
+    this.draggables = new EntityRegistry();
+    this.droppables = new EntityRegistry();
     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);
@@ -676,22 +759,24 @@ function DragOperationManager(manager) {
   const dragended = signal(true);
   let previousSource;
   const source = computed(() => {
+    var _a;
     const identifier = sourceIdentifier.value;
-    if (identifier == null)
-      return null;
+    if (identifier == null) return null;
     const value = draggables.get(identifier);
     if (value) {
       previousSource = value;
     }
-    return value ?? previousSource ?? null;
+    return (_a = value != null ? value : previousSource) != null ? _a : null;
   });
   const target = computed(() => {
+    var _a;
     const identifier = targetIdentifier.value;
-    return identifier != null ? droppables.get(identifier) ?? null : null;
+    return identifier != null ? (_a = droppables.get(identifier)) != null ? _a : null : null;
   });
   const transform = computed(() => {
+    var _a, _b;
     const { x, y } = position.delta;
-    const modifiers = source?.value?.modifiers ?? manager.modifiers;
+    const modifiers = (_b = (_a = source == null ? void 0 : source.value) == null ? void 0 : _a.modifiers) != null ? _b : manager.modifiers;
     let transform2 = { x, y };
     const initialShape = shape.initial.peek();
     const currentShape = shape.current.peek();
@@ -713,7 +798,7 @@ function DragOperationManager(manager) {
       position
     };
     for (const modifier of modifiers) {
-      transform2 = modifier.apply({ ...operation2, transform: transform2 });
+      transform2 = modifier.apply(__spreadProps(__spreadValues({}, operation2), { transform: transform2 }));
     }
     return transform2;
   });
@@ -759,7 +844,8 @@ function DragOperationManager(manager) {
       return initial && current ? { initial, current } : null;
     },
     set shape(value) {
-      if (value && shape.current.peek()?.equals(value)) {
+      var _a;
+      if (value && ((_a = shape.current.peek()) == null ? void 0 : _a.equals(value))) {
         return;
       }
       const initial = shape.initial.peek();
@@ -790,7 +876,7 @@ function DragOperationManager(manager) {
         sourceIdentifier.value = identifier;
       },
       setDropTarget(identifier) {
-        const id = identifier ?? null;
+        const id = identifier != null ? identifier : null;
         if (targetIdentifier.peek() === id) {
           return Promise.resolve();
         }
@@ -852,7 +938,7 @@ function DragOperationManager(manager) {
           if (event.defaultPrevented) {
             return;
           }
-          const coordinates = to ?? {
+          const coordinates = to != null ? to : {
             x: position.current.x + by.x,
             y: position.current.y + by.y
           };
@@ -899,9 +985,7 @@ function DragOperationManager(manager) {
   };
 }
 function snapshot(obj) {
-  return {
-    ...obj
-  };
+  return __spreadValues({}, obj);
 }
 
 // src/core/manager/renderer.ts
@@ -913,19 +997,13 @@ var defaultRenderer = {
 
 // src/core/manager/manager.ts
 var DragDropManager = class {
-  actions;
-  collisionObserver;
-  dragOperation;
-  monitor;
-  registry;
-  renderer;
   constructor(config) {
     const {
       plugins = [],
       sensors = [],
       modifiers = [],
       renderer = defaultRenderer
-    } = config ?? {};
+    } = config != null ? config : {};
     const monitor = new DragDropMonitor(this);
     const registry = new DragDropRegistry(this);
     this.registry = registry;
@@ -938,6 +1016,7 @@ var DragDropManager = class {
     this.plugins = [CollisionNotifier, ...plugins];
     this.modifiers = modifiers;
     this.sensors = sensors;
+    this.destroy = this.destroy.bind(this);
   }
   get plugins() {
     return this.registry.plugins.values;