@vuu-ui/vuu-utils 0.13.11 → 0.13.13

package/cjs/node_modules/@dnd-kit/abstract/index.js

@@ -205,6 +205,377 @@ __decoratorMetadata(_init, Plugin);
 var CorePlugin = class extends Plugin {
 };
 
+// src/core/plugins/registry.ts
+var _previousValues;
+var PluginRegistry = class {
+  /**
+   * Creates a new plugin registry.
+   *
+   * @param manager - The drag and drop manager that owns this registry
+   */
+  constructor(manager) {
+    this.manager = manager;
+    this.instances = /* @__PURE__ */ new Map();
+    __privateAdd(this, _previousValues, []);
+  }
+  /**
+   * Gets all registered plugin instances.
+   *
+   * @returns An array of all active plugin instances
+   */
+  get values() {
+    return Array.from(this.instances.values());
+  }
+  /**
+   * Sets the list of plugins to be used by the registry.
+   *
+   * @param entries - Array of plugin constructors or descriptors
+   * @remarks
+   * This method:
+   * - Filters out duplicate plugins
+   * - Unregisters plugins that are no longer in use
+   * - Registers new plugins with their options
+   */
+  set values(entries) {
+    const descriptors = entries.map(descriptor).reduceRight((acc, descriptor2) => {
+      if (acc.some(({ plugin }) => plugin === descriptor2.plugin)) {
+        return acc;
+      }
+      return [descriptor2, ...acc];
+    }, []);
+    const constructors = descriptors.map(({ plugin }) => plugin);
+    for (const plugin of __privateGet(this, _previousValues)) {
+      if (!constructors.includes(plugin)) {
+        if (plugin.prototype instanceof CorePlugin) {
+          continue;
+        }
+        this.unregister(plugin);
+      }
+    }
+    for (const { plugin, options } of descriptors) {
+      this.register(plugin, options);
+    }
+    __privateSet(this, _previousValues, constructors);
+  }
+  /**
+   * Gets a plugin instance by its constructor.
+   *
+   * @param plugin - The plugin constructor to look up
+   * @returns The plugin instance or undefined if not found
+   */
+  get(plugin) {
+    const instance = this.instances.get(plugin);
+    return instance;
+  }
+  /**
+   * Registers a new plugin instance.
+   *
+   * @param plugin - The plugin constructor to register
+   * @param options - Optional configuration for the plugin
+   * @returns The registered plugin instance
+   * @remarks
+   * If the plugin is already registered, its options will be updated
+   * and the existing instance will be returned.
+   */
+  register(plugin, options) {
+    const existingInstance = this.instances.get(plugin);
+    if (existingInstance) {
+      if (existingInstance.options !== options) {
+        existingInstance.options = options;
+      }
+      return existingInstance;
+    }
+    const instance = new plugin(this.manager, options);
+    this.instances.set(plugin, instance);
+    return instance;
+  }
+  /**
+   * Unregisters a plugin instance.
+   *
+   * @param plugin - The plugin constructor to unregister
+   * @remarks
+   * This method:
+   * - Destroys the plugin instance
+   * - Removes it from the registry
+   */
+  unregister(plugin) {
+    const instance = this.instances.get(plugin);
+    if (instance) {
+      instance.destroy();
+      this.instances.delete(plugin);
+    }
+  }
+  /**
+   * Destroys all registered plugin instances.
+   *
+   * @remarks
+   * This method:
+   * - Calls destroy() on all plugin instances
+   * - Clears the registry
+   */
+  destroy() {
+    for (const plugin of this.instances.values()) {
+      plugin.destroy();
+    }
+    this.instances.clear();
+  }
+};
+_previousValues = new WeakMap();
+
+// src/core/collision/utilities.ts
+function sortCollisions(a, b) {
+  if (a.priority === b.priority) {
+    if (a.type === b.type) {
+      return b.value - a.value;
+    }
+    return b.type - a.type;
+  }
+  return b.priority - a.priority;
+}
+
+// src/core/collision/observer.ts
+var DEFAULT_VALUE = [];
+var _previousCoordinates, _collisions;
+var CollisionObserver = class extends Plugin {
+  /**
+   * Creates a new CollisionObserver instance.
+   *
+   * @param manager - The drag drop manager instance
+   */
+  constructor(manager) {
+    super(manager);
+    __privateAdd(this, _previousCoordinates);
+    __privateAdd(this, _collisions);
+    this.computeCollisions = this.computeCollisions.bind(this);
+    __privateSet(this, _collisions, signalsCore.signal(DEFAULT_VALUE));
+    this.destroy = index.effects(
+      () => {
+        const collisions = this.computeCollisions();
+        const coordinates = signalsCore.untracked(
+          () => this.manager.dragOperation.position.current
+        );
+        if (collisions !== DEFAULT_VALUE) {
+          const previousCoordinates = __privateGet(this, _previousCoordinates);
+          __privateSet(this, _previousCoordinates, coordinates);
+          if (previousCoordinates && coordinates.x == previousCoordinates.x && coordinates.y == previousCoordinates.y) {
+            return;
+          }
+        } else {
+          __privateSet(this, _previousCoordinates, void 0);
+        }
+        __privateGet(this, _collisions).value = collisions;
+      },
+      () => {
+        const { dragOperation } = this.manager;
+        if (dragOperation.status.initialized) {
+          this.forceUpdate();
+        }
+      }
+    );
+  }
+  /**
+   * Forces an immediate update of collision detection.
+   *
+   * @param immediate - If true, updates collisions immediately. If false, resets previous coordinates.
+   */
+  forceUpdate(immediate = true) {
+    signalsCore.untracked(() => {
+      if (immediate) {
+        __privateGet(this, _collisions).value = this.computeCollisions();
+      } else {
+        __privateSet(this, _previousCoordinates, void 0);
+      }
+    });
+  }
+  /**
+   * Computes collisions between draggable and droppable elements.
+   *
+   * @param entries - Optional array of droppable elements to check. If not provided, uses all registered droppables.
+   * @param collisionDetector - Optional custom collision detector function
+   * @returns Array of detected collisions, sorted by priority
+   */
+  computeCollisions(entries, collisionDetector) {
+    const { registry, dragOperation } = this.manager;
+    const { source, shape, status } = dragOperation;
+    if (!status.initialized || !shape) {
+      return DEFAULT_VALUE;
+    }
+    const collisions = [];
+    const potentialTargets = [];
+    for (const entry of entries != null ? entries : registry.droppables) {
+      if (entry.disabled) {
+        continue;
+      }
+      if (source && !entry.accepts(source)) {
+        continue;
+      }
+      const detectCollision = collisionDetector != null ? collisionDetector : entry.collisionDetector;
+      if (!detectCollision) {
+        continue;
+      }
+      potentialTargets.push(entry);
+      void entry.shape;
+      const collision = signalsCore.untracked(
+        () => detectCollision({
+          droppable: entry,
+          dragOperation
+        })
+      );
+      if (collision) {
+        if (entry.collisionPriority != null) {
+          collision.priority = entry.collisionPriority;
+        }
+        collisions.push(collision);
+      }
+    }
+    if (potentialTargets.length === 0) {
+      return DEFAULT_VALUE;
+    }
+    collisions.sort(sortCollisions);
+    return collisions;
+  }
+  /**
+   * Gets the current collisions signal value.
+   */
+  get collisions() {
+    return __privateGet(this, _collisions).value;
+  }
+};
+_previousCoordinates = new WeakMap();
+_collisions = new WeakMap();
+
+// src/core/manager/events.ts
+var Monitor = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds an event listener for the specified event type.
+   *
+   * @param name - The name of the event to listen for
+   * @param handler - The function to call when the event occurs
+   * @returns A function to remove the event listener
+   */
+  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);
+  }
+  /**
+   * Removes an event listener for the specified event type.
+   *
+   * @param name - The name of the event
+   * @param handler - The function to remove
+   */
+  removeEventListener(name, handler) {
+    const { registry } = this;
+    const listeners = new Set(registry.get(name));
+    listeners.delete(handler);
+    registry.set(name, listeners);
+  }
+  /**
+   * Dispatches an event to all registered listeners.
+   *
+   * @param name - The name of the event to dispatch
+   * @param args - Arguments to pass to the event handlers
+   */
+  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 {
+  /**
+   * Creates a new drag and drop monitor.
+   *
+   * @param manager - The drag and drop manager to monitor
+   */
+  constructor(manager) {
+    super();
+    this.manager = manager;
+  }
+  /**
+   * Dispatches a drag and drop event.
+   *
+   * @param type - The type of event to dispatch
+   * @param event - The event data to dispatch
+   */
+  dispatch(type, event) {
+    const args = [event, this.manager];
+    super.dispatch(type, ...args);
+  }
+};
+function defaultPreventable(event, cancelable = true) {
+  let defaultPrevented = false;
+  return __spreadProps(__spreadValues({}, 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);
+    const isEqual = (a, b) => a.map(({ id }) => id).join("") === b.map(({ id }) => id).join("");
+    let previousCollisions = [];
+    this.destroy = index.effects(
+      () => {
+        const { dragOperation, collisionObserver } = manager;
+        if (dragOperation.status.initializing) {
+          previousCollisions = [];
+          collisionObserver.enable();
+        }
+      },
+      () => {
+        const { collisionObserver, monitor } = manager;
+        const { collisions } = collisionObserver;
+        if (collisionObserver.isDisabled()) {
+          return;
+        }
+        const event = defaultPreventable({
+          collisions
+        });
+        monitor.dispatch("collision", event);
+        if (event.defaultPrevented) {
+          return;
+        }
+        if (isEqual(collisions, previousCollisions)) {
+          return;
+        } else {
+          previousCollisions = collisions;
+        }
+        const [firstCollision] = collisions;
+        signalsCore.untracked(() => {
+          var _a;
+          if ((firstCollision == null ? void 0 : firstCollision.id) !== ((_a = manager.dragOperation.target) == null ? void 0 : _a.id)) {
+            collisionObserver.disable();
+            manager.actions.setDropTarget(firstCollision == null ? void 0 : firstCollision.id).then(() => {
+              collisionObserver.enable();
+            });
+          }
+        });
+      }
+    );
+  }
+};
+
 // src/core/collision/types.ts
 var CollisionPriority = /* @__PURE__ */ ((CollisionPriority2) => {
   CollisionPriority2[CollisionPriority2["Lowest"] = 0] = "Lowest";
@@ -265,6 +636,227 @@ __decorateElement(_init2, 2, "initialized", _initialized_dec, Status);
 __decorateElement(_init2, 2, "dragging", _dragging_dec, Status);
 __decorateElement(_init2, 2, "dropped", _dropped_dec, Status);
 __decoratorMetadata(_init2, Status);
+
+// src/core/manager/actions.ts
+var DragActions = class {
+  /**
+   * Creates a new instance of drag actions.
+   *
+   * @param manager - The drag and drop manager instance
+   */
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Sets the source of the drag operation.
+   *
+   * @param source - The draggable entity or its unique identifier
+   */
+  setDragSource(source) {
+    const { dragOperation } = this.manager;
+    dragOperation.sourceIdentifier = typeof source === "string" || typeof source === "number" ? source : source.id;
+  }
+  /**
+   * Sets the target of the drop operation.
+   *
+   * @param identifier - The unique identifier of the droppable entity or null/undefined
+   * @returns A promise that resolves to true if the drop was prevented
+   */
+  setDropTarget(identifier) {
+    return signalsCore.untracked(() => {
+      const { dragOperation } = this.manager;
+      const id = identifier != null ? identifier : null;
+      if (dragOperation.targetIdentifier === id) {
+        return Promise.resolve(false);
+      }
+      dragOperation.targetIdentifier = id;
+      const event = defaultPreventable({
+        operation: dragOperation.snapshot()
+      });
+      if (dragOperation.status.dragging) {
+        this.manager.monitor.dispatch("dragover", event);
+      }
+      return this.manager.renderer.rendering.then(() => event.defaultPrevented);
+    });
+  }
+  /**
+   * Starts a new drag operation.
+   *
+   * @param args - Configuration for the drag operation
+   * @param args.event - The event that initiated the drag
+   * @param args.source - The source draggable entity or its identifier
+   * @param args.coordinates - The initial coordinates of the drag
+   * @returns true if the drag operation started successfully
+   * @throws {Error} If there is no drag source or another operation is active
+   */
+  start(args) {
+    return signalsCore.untracked(() => {
+      const { dragOperation } = this.manager;
+      if (args.source != null) {
+        this.setDragSource(args.source);
+      }
+      const sourceInstance = dragOperation.source;
+      if (!sourceInstance) {
+        throw new Error("Cannot start a drag operation without a drag source");
+      }
+      if (!dragOperation.status.idle) {
+        throw new Error(
+          "Cannot start a drag operation while another is active"
+        );
+      }
+      const controller = new AbortController();
+      const { event: nativeEvent, coordinates } = args;
+      signalsCore.batch(() => {
+        dragOperation.status.set("initialization-pending" /* InitializationPending */);
+        dragOperation.shape = null;
+        dragOperation.canceled = false;
+        dragOperation.activatorEvent = nativeEvent != null ? nativeEvent : null;
+        dragOperation.position.reset(coordinates);
+      });
+      const beforeStartEvent = defaultPreventable({
+        operation: dragOperation.snapshot()
+      });
+      this.manager.monitor.dispatch("beforedragstart", beforeStartEvent);
+      if (beforeStartEvent.defaultPrevented) {
+        dragOperation.reset();
+        controller.abort();
+        return controller;
+      }
+      dragOperation.status.set("initializing" /* Initializing */);
+      dragOperation.controller = controller;
+      this.manager.renderer.rendering.then(() => {
+        if (controller.signal.aborted) return;
+        const { status } = dragOperation;
+        if (status.current !== "initializing" /* Initializing */) return;
+        dragOperation.status.set("dragging" /* Dragging */);
+        this.manager.monitor.dispatch("dragstart", {
+          nativeEvent,
+          operation: dragOperation.snapshot(),
+          cancelable: false
+        });
+      });
+      return controller;
+    });
+  }
+  /**
+   * Moves the dragged entity to a new position.
+   *
+   * @param args - Configuration for the move operation
+   * @param args.by - Relative coordinates to move by
+   * @param args.to - Absolute coordinates to move to
+   * @param args.event - The event that triggered the move
+   * @param args.cancelable - Whether the move can be canceled
+   * @param args.propagate - Whether to dispatch dragmove events
+   */
+  move(args) {
+    return signalsCore.untracked(() => {
+      var _a, _b;
+      const { dragOperation } = this.manager;
+      const { status, controller } = dragOperation;
+      if (!status.dragging || !controller || controller.signal.aborted) {
+        return;
+      }
+      const event = defaultPreventable(
+        {
+          nativeEvent: args.event,
+          operation: dragOperation.snapshot(),
+          by: args.by,
+          to: args.to
+        },
+        (_a = args.cancelable) != null ? _a : true
+      );
+      if ((_b = args.propagate) != null ? _b : true) {
+        this.manager.monitor.dispatch("dragmove", event);
+      }
+      queueMicrotask(() => {
+        var _a2, _b2, _c3, _d, _e;
+        if (event.defaultPrevented) {
+          return;
+        }
+        const coordinates = (_e = args.to) != null ? _e : {
+          x: dragOperation.position.current.x + ((_b2 = (_a2 = args.by) == null ? void 0 : _a2.x) != null ? _b2 : 0),
+          y: dragOperation.position.current.y + ((_d = (_c3 = args.by) == null ? void 0 : _c3.y) != null ? _d : 0)
+        };
+        dragOperation.position.current = coordinates;
+      });
+    });
+  }
+  /**
+   * Stops the current drag operation.
+   *
+   * @param args - Configuration for stopping the operation
+   * @param args.event - The event that triggered the stop
+   * @param args.canceled - Whether the operation was canceled
+   * @remarks
+   * This method:
+   * - Dispatches a dragend event
+   * - Allows suspension of the operation
+   * - Handles cleanup of the operation state
+   */
+  stop(args = {}) {
+    return signalsCore.untracked(() => {
+      var _a, _b;
+      const { dragOperation } = this.manager;
+      const { controller } = dragOperation;
+      if (!controller || controller.signal.aborted) return;
+      let promise;
+      const suspend = () => {
+        const output = {
+          resume: () => {
+          },
+          abort: () => {
+          }
+        };
+        promise = new Promise((resolve, reject) => {
+          output.resume = resolve;
+          output.abort = reject;
+        });
+        return output;
+      };
+      controller.abort();
+      const end = () => {
+        this.manager.renderer.rendering.then(() => {
+          dragOperation.status.set("dropped" /* Dropped */);
+          const dropping = signalsCore.untracked(
+            () => {
+              var _a2;
+              return ((_a2 = dragOperation.source) == null ? void 0 : _a2.status) === "dropping";
+            }
+          );
+          const cleanup = () => {
+            if (dragOperation.controller === controller) {
+              dragOperation.controller = void 0;
+            }
+            dragOperation.reset();
+          };
+          if (dropping) {
+            const { source } = dragOperation;
+            const dispose = signalsCore.effect(() => {
+              if ((source == null ? void 0 : source.status) === "idle") {
+                dispose();
+                cleanup();
+              }
+            });
+          } else {
+            this.manager.renderer.rendering.then(cleanup);
+          }
+        });
+      };
+      dragOperation.canceled = (_a = args.canceled) != null ? _a : false;
+      this.manager.monitor.dispatch("dragend", {
+        nativeEvent: args.event,
+        operation: dragOperation.snapshot(),
+        canceled: (_b = args.canceled) != null ? _b : false,
+        suspend
+      });
+      if (promise) {
+        promise.then(end).catch(() => dragOperation.reset());
+      } else {
+        end();
+      }
+    });
+  }
+};
 var _disabled_dec2, _data_dec, _id_dec, _manager_dec, _init3, _manager, _id, _data, _disabled2;
 _manager_dec = [index.reactive], _id_dec = [index.reactive], _data_dec = [index.reactive], _disabled_dec2 = [index.reactive];
 var Entity = class {
@@ -341,6 +933,89 @@ __decorateElement(_init3, 4, "id", _id_dec, Entity, _id);
 __decorateElement(_init3, 4, "data", _data_dec, Entity, _data);
 __decorateElement(_init3, 4, "disabled", _disabled_dec2, Entity, _disabled2);
 __decoratorMetadata(_init3, Entity);
+var EntityRegistry = class {
+  constructor() {
+    this.map = signalsCore.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();
+      const currentValue = current.get(key);
+      const unregister = () => this.unregister(key, value);
+      if (currentValue === value) return unregister;
+      if (currentValue) {
+        const cleanup2 = this.cleanupFunctions.get(currentValue);
+        cleanup2 == null ? void 0 : cleanup2();
+        this.cleanupFunctions.delete(currentValue);
+      }
+      const updatedMap = new Map(current);
+      updatedMap.set(key, value);
+      this.map.value = updatedMap;
+      const cleanup = index.effects(...value.effects());
+      this.cleanupFunctions.set(value, cleanup);
+      return unregister;
+    };
+    /**
+     * 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.
+   */
+  [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);
+  }
+  /**
+   * Destroys all entries in the registry and clears the registry.
+   */
+  destroy() {
+    for (const entry of this) {
+      const cleanup = this.cleanupFunctions.get(entry);
+      cleanup == null ? void 0 : cleanup();
+      entry.destroy();
+    }
+    this.map.value = /* @__PURE__ */ new Map();
+  }
+};
 var _isDragSource_dec, _isDragging_dec, _isDropping_dec, _status_dec, _modifiers_dec, _type_dec, _c, _init4, _type, _modifiers, _status;
 var Draggable$1 = class Draggable extends (_c = Entity, _type_dec = [index.reactive], _modifiers_dec = [index.reactive], _status_dec = [index.reactive], _isDropping_dec = [index.derived], _isDragging_dec = [index.derived], _isDragSource_dec = [index.derived], _c) {
   constructor(_a, manager) {
@@ -476,6 +1151,80 @@ var Modifier = class extends Plugin {
     return operation.transform;
   }
 };
+
+// src/core/manager/registry.ts
+var DragDropRegistry = class {
+  /**
+   * Creates a new registry instance.
+   *
+   * @param manager - The drag and drop manager that owns this registry
+   */
+  constructor(manager) {
+    /** Registry for draggable entities */
+    this.draggables = new EntityRegistry();
+    /** Registry for droppable entities */
+    this.droppables = new EntityRegistry();
+    this.plugins = new PluginRegistry(manager);
+    this.sensors = new PluginRegistry(manager);
+    this.modifiers = new PluginRegistry(manager);
+  }
+  register(input, options) {
+    if (input instanceof Draggable$1) {
+      return this.draggables.register(input.id, input);
+    }
+    if (input instanceof Droppable$1) {
+      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$1) {
+        return this.draggables.unregister(input.id, input);
+      }
+      if (input instanceof Droppable$1) {
+        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");
+  }
+  /**
+   * Destroys all registered entities and cleans up resources.
+   *
+   * @remarks
+   * This method:
+   * - Destroys all draggable and droppable entities
+   * - Destroys all plugins, sensors, and modifiers
+   * - Cleans up any associated resources
+   */
+  destroy() {
+    this.draggables.destroy();
+    this.droppables.destroy();
+    this.plugins.destroy();
+    this.sensors.destroy();
+    this.modifiers.destroy();
+  }
+};
 var _transform_dec, _target_dec, _source_dec, _modifiers_dec2, _targetIdentifier_dec, _sourceIdentifier_dec, _activatorEvent_dec, _canceled_dec, _shape_dec2, _manager2, _previousSource, _shape2, _init6, _canceled, _activatorEvent, _sourceIdentifier, _targetIdentifier, _modifiers2, _transform;
 _shape_dec2 = [index.derived], _canceled_dec = [index.reactive], _activatorEvent_dec = [index.reactive], _sourceIdentifier_dec = [index.reactive], _targetIdentifier_dec = [index.reactive], _modifiers_dec2 = [index.reactive], _source_dec = [index.derived], _target_dec = [index.derived], _transform_dec = [index.derived];
 var DragOperation = class {
@@ -610,16 +1359,130 @@ __decorateElement(_init6, 2, "target", _target_dec, DragOperation);
 __decorateElement(_init6, 2, "transform", _transform_dec, DragOperation);
 __decoratorMetadata(_init6, DragOperation);
 
+// src/core/manager/renderer.ts
+var defaultRenderer = {
+  get rendering() {
+    return Promise.resolve();
+  }
+};
+
+// src/core/manager/manager.ts
+var DragDropManager$1 = class DragDropManager {
+  /**
+   * Creates a new drag and drop manager instance.
+   *
+   * @param config - Optional configuration for plugins, sensors, modifiers, and renderer
+   */
+  constructor(config) {
+    /**
+     * Cleans up resources and stops any active drag operations.
+     */
+    this.destroy = () => {
+      if (!this.dragOperation.status.idle) {
+        this.actions.stop({ canceled: true });
+      }
+      this.dragOperation.modifiers.forEach((modifier) => modifier.destroy());
+      this.registry.destroy();
+      this.collisionObserver.destroy();
+    };
+    const {
+      plugins = [],
+      sensors = [],
+      modifiers = [],
+      renderer = defaultRenderer
+    } = config != null ? config : {};
+    const monitor = new DragDropMonitor(this);
+    const registry = new DragDropRegistry(this);
+    this.registry = registry;
+    this.monitor = monitor;
+    this.renderer = renderer;
+    this.actions = new DragActions(this);
+    this.dragOperation = new DragOperation(this);
+    this.collisionObserver = new CollisionObserver(this);
+    this.plugins = [CollisionNotifier, ...plugins];
+    this.modifiers = modifiers;
+    this.sensors = sensors;
+    const { destroy } = this;
+    const cleanup = index.effects(() => {
+      var _a, _b, _c3;
+      const currentModifiers = signalsCore.untracked(() => this.dragOperation.modifiers);
+      const managerModifiers = this.modifiers;
+      if (currentModifiers !== managerModifiers) {
+        currentModifiers.forEach((modifier) => modifier.destroy());
+      }
+      this.dragOperation.modifiers = (_c3 = (_b = (_a = this.dragOperation.source) == null ? void 0 : _a.modifiers) == null ? void 0 : _b.map((modifier) => {
+        const { plugin, options } = descriptor(modifier);
+        return new plugin(this, options);
+      })) != null ? _c3 : managerModifiers;
+    });
+    this.destroy = () => {
+      cleanup();
+      destroy();
+    };
+  }
+  /**
+   * Gets the list of active plugins.
+   *
+   * @returns Array of active plugin instances
+   */
+  get plugins() {
+    return this.registry.plugins.values;
+  }
+  /**
+   * Sets the list of plugins to be used by the manager.
+   *
+   * @param plugins - Array of plugin constructors or instances
+   */
+  set plugins(plugins) {
+    this.registry.plugins.values = plugins;
+  }
+  /**
+   * Gets the list of active modifiers.
+   *
+   * @returns Array of active modifier instances
+   */
+  get modifiers() {
+    return this.registry.modifiers.values;
+  }
+  /**
+   * Sets the list of modifiers to be used by the manager.
+   *
+   * @param modifiers - Array of modifier constructors or instances
+   */
+  set modifiers(modifiers) {
+    this.registry.modifiers.values = modifiers;
+  }
+  /**
+   * Gets the list of active sensors.
+   *
+   * @returns Array of active sensor instances
+   */
+  get sensors() {
+    return this.registry.sensors.values;
+  }
+  /**
+   * Sets the list of sensors to be used by the manager.
+   *
+   * @param sensors - Array of sensor constructors or instances
+   */
+  set sensors(sensors) {
+    this.registry.sensors.values = sensors;
+  }
+};
+
 exports.CollisionPriority = CollisionPriority;
 exports.CollisionType = CollisionType;
 exports.CorePlugin = CorePlugin;
+exports.DragDropManager = DragDropManager$1;
 exports.DragOperationStatus = Status;
 exports.Draggable = Draggable$1;
 exports.Droppable = Droppable$1;
 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=index.js.map