@vuu-ui/vuu-ui-controls 0.13.2 → 0.13.3

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

@@ -0,0 +1,596 @@
+'use strict';
+
+var index = require('../state/dist/index.js');
+var index$1 = require('../geometry/dist/index.js');
+var signalsCore = require('../../@preact/signals-core/dist/signals-core.js');
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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) {
+  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 _disabled_dec, _init, _disabled, _cleanupFunctions;
+_disabled_dec = [index.reactive];
+var Plugin = class {
+  /**
+   * Creates a new plugin instance.
+   *
+   * @param manager - The drag and drop manager that owns this plugin
+   * @param options - Optional configuration for the plugin
+   */
+  constructor(manager, options) {
+    this.manager = manager;
+    this.options = options;
+    __privateAdd(this, _disabled, __runInitializers(_init, 8, this, false)), __runInitializers(_init, 11, this);
+    __privateAdd(this, _cleanupFunctions, /* @__PURE__ */ new Set());
+  }
+  /**
+   * Enables a disabled plugin instance.
+   *
+   * @remarks
+   * This method triggers effects when called.
+   */
+  enable() {
+    this.disabled = false;
+  }
+  /**
+   * Disables an enabled plugin instance.
+   *
+   * @remarks
+   * This method triggers effects when called.
+   */
+  disable() {
+    this.disabled = true;
+  }
+  /**
+   * Checks if the plugin instance is disabled.
+   *
+   * @returns true if the plugin is disabled
+   * @remarks
+   * This method does not trigger effects when accessed.
+   */
+  isDisabled() {
+    return signalsCore.untracked(() => {
+      return this.disabled;
+    });
+  }
+  /**
+   * Configures a plugin instance with new options.
+   *
+   * @param options - The new options to apply
+   */
+  configure(options) {
+    this.options = options;
+  }
+  /**
+   * Registers an effect that will be cleaned up when the plugin is destroyed.
+   *
+   * @param callback - The effect callback to register
+   * @returns A function to dispose of the effect
+   */
+  registerEffect(callback) {
+    const dispose = signalsCore.effect(callback.bind(this));
+    __privateGet(this, _cleanupFunctions).add(dispose);
+    return dispose;
+  }
+  /**
+   * Destroys a plugin instance and cleans up its resources.
+   *
+   * @remarks
+   * This method:
+   * - Calls all registered cleanup functions
+   * - Should be overridden by subclasses to clean up additional resources
+   */
+  destroy() {
+    __privateGet(this, _cleanupFunctions).forEach((cleanup) => cleanup());
+  }
+  /**
+   * Configures a plugin constructor with options.
+   *
+   * @param options - The options to configure the constructor with
+   * @returns The configured plugin constructor
+   *
+   * @remarks
+   * 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);
+  }
+};
+_init = __decoratorStart(null);
+_disabled = new WeakMap();
+_cleanupFunctions = new WeakMap();
+__decorateElement(_init, 4, "disabled", _disabled_dec, Plugin, _disabled);
+__decoratorMetadata(_init, Plugin);
+var CorePlugin = class extends Plugin {
+};
+
+// 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 CollisionType = /* @__PURE__ */ ((CollisionType2) => {
+  CollisionType2[CollisionType2["Collision"] = 0] = "Collision";
+  CollisionType2[CollisionType2["ShapeIntersection"] = 1] = "ShapeIntersection";
+  CollisionType2[CollisionType2["PointerIntersection"] = 2] = "PointerIntersection";
+  return CollisionType2;
+})(CollisionType || {});
+var _dropped_dec, _dragging_dec, _initialized_dec, _initializing_dec, _idle_dec, _current_dec, _value_dec, _init2, _value;
+_value_dec = [index.reactive], _current_dec = [index.derived], _idle_dec = [index.derived], _initializing_dec = [index.derived], _initialized_dec = [index.derived], _dragging_dec = [index.derived], _dropped_dec = [index.derived];
+var Status = class {
+  constructor() {
+    __runInitializers(_init2, 5, this);
+    __privateAdd(this, _value, __runInitializers(_init2, 8, this, "idle" /* Idle */)), __runInitializers(_init2, 11, this);
+  }
+  get current() {
+    return this.value;
+  }
+  get idle() {
+    return this.value === "idle" /* Idle */;
+  }
+  get initializing() {
+    return this.value === "initializing" /* Initializing */;
+  }
+  get initialized() {
+    const { value } = this;
+    return value !== "idle" /* Idle */ && value !== "initialization-pending" /* InitializationPending */;
+  }
+  get dragging() {
+    return this.value === "dragging" /* Dragging */;
+  }
+  get dropped() {
+    return this.value === "dropped" /* Dropped */;
+  }
+  /**
+   * Sets the current status value.
+   *
+   * @param value - The new status value
+   */
+  set(value) {
+    this.value = value;
+  }
+};
+_init2 = __decoratorStart(null);
+_value = new WeakMap();
+__decorateElement(_init2, 4, "value", _value_dec, Status, _value);
+__decorateElement(_init2, 2, "current", _current_dec, Status);
+__decorateElement(_init2, 2, "idle", _idle_dec, Status);
+__decorateElement(_init2, 2, "initializing", _initializing_dec, Status);
+__decorateElement(_init2, 2, "initialized", _initialized_dec, Status);
+__decorateElement(_init2, 2, "dragging", _dragging_dec, Status);
+__decorateElement(_init2, 2, "dropped", _dropped_dec, Status);
+__decoratorMetadata(_init2, Status);
+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 {
+  /**
+   * 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) {
+    __privateAdd(this, _manager, __runInitializers(_init3, 8, this)), __runInitializers(_init3, 11, this);
+    __privateAdd(this, _id, __runInitializers(_init3, 12, this)), __runInitializers(_init3, 15, this);
+    __privateAdd(this, _data, __runInitializers(_init3, 16, this)), __runInitializers(_init3, 19, this);
+    __privateAdd(this, _disabled2, __runInitializers(_init3, 20, this)), __runInitializers(_init3, 23, this);
+    const { effects: effects6, id, data = {}, disabled = false, register = true } = input;
+    let previousId = id;
+    this.manager = manager;
+    this.id = id;
+    this.data = data;
+    this.disabled = disabled;
+    this.effects = () => {
+      var _a;
+      return [
+        () => {
+          const { id: id2, manager: manager2 } = this;
+          if (id2 === previousId) {
+            return;
+          }
+          manager2 == null ? void 0 : manager2.registry.register(this);
+          return () => manager2 == null ? void 0 : manager2.registry.unregister(this);
+        },
+        ...(_a = effects6 == null ? void 0 : effects6()) != null ? _a : []
+      ];
+    };
+    this.register = this.register.bind(this);
+    this.unregister = this.unregister.bind(this);
+    this.destroy = this.destroy.bind(this);
+    if (manager && register) {
+      queueMicrotask(this.register);
+    }
+  }
+  /**
+   * A method that registers the entity with the manager.
+   * @returns CleanupFunction | void
+   */
+  register() {
+    var _a;
+    return (_a = this.manager) == null ? void 0 : _a.registry.register(this);
+  }
+  /**
+   * A method that unregisters the entity from the manager.
+   * @returns void
+   */
+  unregister() {
+    var _a;
+    (_a = this.manager) == null ? void 0 : _a.registry.unregister(this);
+  }
+  /**
+   * A method that cleans up the entity when it is no longer needed.
+   * @returns void
+   */
+  destroy() {
+    var _a;
+    (_a = this.manager) == null ? void 0 : _a.registry.unregister(this);
+  }
+};
+_init3 = __decoratorStart(null);
+_manager = new WeakMap();
+_id = new WeakMap();
+_data = new WeakMap();
+_disabled2 = new WeakMap();
+__decorateElement(_init3, 4, "manager", _manager_dec, Entity, _manager);
+__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 _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) {
+    var _b = _a, { modifiers, type, sensors } = _b, input = __objRest(_b, ["modifiers", "type", "sensors"]);
+    super(input, manager);
+    __runInitializers(_init4, 5, this);
+    __privateAdd(this, _type, __runInitializers(_init4, 8, this)), __runInitializers(_init4, 11, this);
+    __privateAdd(this, _modifiers, __runInitializers(_init4, 12, this)), __runInitializers(_init4, 15, this);
+    __privateAdd(this, _status, __runInitializers(_init4, 16, this, this.isDragSource ? "dragging" : "idle")), __runInitializers(_init4, 19, this);
+    this.type = type;
+    this.sensors = sensors;
+    this.modifiers = modifiers;
+    this.alignment = input.alignment;
+  }
+  get isDropping() {
+    return this.status === "dropping" && this.isDragSource;
+  }
+  get isDragging() {
+    return this.status === "dragging" && this.isDragSource;
+  }
+  get isDragSource() {
+    var _a, _b;
+    return ((_b = (_a = this.manager) == null ? void 0 : _a.dragOperation.source) == null ? void 0 : _b.id) === this.id;
+  }
+};
+_init4 = __decoratorStart(_c);
+_type = new WeakMap();
+_modifiers = new WeakMap();
+_status = new WeakMap();
+__decorateElement(_init4, 4, "type", _type_dec, Draggable$1, _type);
+__decorateElement(_init4, 4, "modifiers", _modifiers_dec, Draggable$1, _modifiers);
+__decorateElement(_init4, 4, "status", _status_dec, Draggable$1, _status);
+__decorateElement(_init4, 2, "isDropping", _isDropping_dec, Draggable$1);
+__decorateElement(_init4, 2, "isDragging", _isDragging_dec, Draggable$1);
+__decorateElement(_init4, 2, "isDragSource", _isDragSource_dec, Draggable$1);
+__decoratorMetadata(_init4, Draggable$1);
+var _isDropTarget_dec, _shape_dec, _collisionPriority_dec, _collisionDetector_dec, _type_dec2, _accept_dec, _c2, _init5, _accept, _type2, _collisionDetector, _collisionPriority, _shape;
+var Droppable$1 = class Droppable extends (_c2 = Entity, _accept_dec = [index.reactive], _type_dec2 = [index.reactive], _collisionDetector_dec = [index.reactive], _collisionPriority_dec = [index.reactive], _shape_dec = [index.reactive], _isDropTarget_dec = [index.derived], _c2) {
+  constructor(_a, manager) {
+    var _b = _a, { accept, collisionDetector, collisionPriority, type } = _b, input = __objRest(_b, ["accept", "collisionDetector", "collisionPriority", "type"]);
+    super(input, manager);
+    __runInitializers(_init5, 5, this);
+    __privateAdd(this, _accept, __runInitializers(_init5, 8, this)), __runInitializers(_init5, 11, this);
+    __privateAdd(this, _type2, __runInitializers(_init5, 12, this)), __runInitializers(_init5, 15, this);
+    __privateAdd(this, _collisionDetector, __runInitializers(_init5, 16, this)), __runInitializers(_init5, 19, this);
+    __privateAdd(this, _collisionPriority, __runInitializers(_init5, 20, this)), __runInitializers(_init5, 23, this);
+    __privateAdd(this, _shape, __runInitializers(_init5, 24, this)), __runInitializers(_init5, 27, this);
+    this.accept = accept;
+    this.collisionDetector = collisionDetector;
+    this.collisionPriority = collisionPriority;
+    this.type = type;
+  }
+  /**
+   * Checks whether or not the droppable accepts a given draggable.
+   *
+   * @param draggable - The draggable to check
+   * @returns true if the draggable can be dropped here
+   */
+  accepts(draggable) {
+    const { accept } = this;
+    if (!accept) {
+      return true;
+    }
+    if (typeof accept === "function") {
+      return accept(draggable);
+    }
+    if (!draggable.type) {
+      return false;
+    }
+    if (Array.isArray(accept)) {
+      return accept.includes(draggable.type);
+    }
+    return draggable.type === accept;
+  }
+  get isDropTarget() {
+    var _a, _b;
+    return ((_b = (_a = this.manager) == null ? void 0 : _a.dragOperation.target) == null ? void 0 : _b.id) === this.id;
+  }
+};
+_init5 = __decoratorStart(_c2);
+_accept = new WeakMap();
+_type2 = new WeakMap();
+_collisionDetector = new WeakMap();
+_collisionPriority = new WeakMap();
+_shape = new WeakMap();
+__decorateElement(_init5, 4, "accept", _accept_dec, Droppable$1, _accept);
+__decorateElement(_init5, 4, "type", _type_dec2, Droppable$1, _type2);
+__decorateElement(_init5, 4, "collisionDetector", _collisionDetector_dec, Droppable$1, _collisionDetector);
+__decorateElement(_init5, 4, "collisionPriority", _collisionPriority_dec, Droppable$1, _collisionPriority);
+__decorateElement(_init5, 4, "shape", _shape_dec, Droppable$1, _shape);
+__decorateElement(_init5, 2, "isDropTarget", _isDropTarget_dec, Droppable$1);
+__decoratorMetadata(_init5, Droppable$1);
+
+// src/core/sensors/sensor.ts
+var Sensor = class extends Plugin {
+  /**
+   * Creates a new sensor instance.
+   *
+   * @param manager - The drag drop manager instance
+   * @param options - Optional sensor configuration
+   */
+  constructor(manager, options) {
+    super(manager, options);
+    this.manager = manager;
+    this.options = options;
+  }
+};
+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 {
+  /**
+   * Creates a new drag operation instance.
+   *
+   * @param manager - The drag and drop manager that owns this operation
+   */
+  constructor(manager) {
+    __runInitializers(_init6, 5, this);
+    __privateAdd(this, _manager2);
+    __privateAdd(this, _previousSource);
+    __privateAdd(this, _shape2, new index.ValueHistory(
+      void 0,
+      (a, b) => a && b ? a.equals(b) : a === b
+    ));
+    /** Current status of the drag operation */
+    this.status = new Status();
+    __privateAdd(this, _canceled, __runInitializers(_init6, 8, this, false)), __runInitializers(_init6, 11, this);
+    __privateAdd(this, _activatorEvent, __runInitializers(_init6, 12, this, null)), __runInitializers(_init6, 15, this);
+    __privateAdd(this, _sourceIdentifier, __runInitializers(_init6, 16, this, null)), __runInitializers(_init6, 19, this);
+    __privateAdd(this, _targetIdentifier, __runInitializers(_init6, 20, this, null)), __runInitializers(_init6, 23, this);
+    __privateAdd(this, _modifiers2, __runInitializers(_init6, 24, this, [])), __runInitializers(_init6, 27, this);
+    /** Current position of the dragged entity */
+    this.position = new index$1.Position({ x: 0, y: 0 });
+    __privateAdd(this, _transform, { x: 0, y: 0 });
+    __privateSet(this, _manager2, manager);
+  }
+  get shape() {
+    const { current, initial, previous } = __privateGet(this, _shape2);
+    if (!current || !initial) {
+      return null;
+    }
+    return { current, initial, previous };
+  }
+  /**
+   * Sets the shape of the dragged entity.
+   *
+   * @param value - The new shape or null to reset
+   */
+  set shape(value) {
+    if (!value) {
+      __privateGet(this, _shape2).reset();
+    } else {
+      __privateGet(this, _shape2).current = value;
+    }
+  }
+  get source() {
+    var _a;
+    const identifier = this.sourceIdentifier;
+    if (identifier == null) return null;
+    const value = __privateGet(this, _manager2).registry.draggables.get(identifier);
+    if (value) {
+      __privateSet(this, _previousSource, value);
+    }
+    return (_a = value != null ? value : __privateGet(this, _previousSource)) != null ? _a : null;
+  }
+  get target() {
+    var _a;
+    const identifier = this.targetIdentifier;
+    return identifier != null ? (_a = __privateGet(this, _manager2).registry.droppables.get(identifier)) != null ? _a : null : null;
+  }
+  get transform() {
+    const { x, y } = this.position.delta;
+    let transform = { x, y };
+    for (const modifier of this.modifiers) {
+      transform = modifier.apply(__spreadProps(__spreadValues({}, this.snapshot()), {
+        transform
+      }));
+    }
+    __privateSet(this, _transform, transform);
+    return transform;
+  }
+  /**
+   * Creates a snapshot of the current drag operation state.
+   *
+   * @returns An immutable snapshot of the current operation state
+   */
+  snapshot() {
+    return signalsCore.untracked(() => ({
+      source: this.source,
+      target: this.target,
+      activatorEvent: this.activatorEvent,
+      transform: __privateGet(this, _transform),
+      shape: this.shape ? index.snapshot(this.shape) : null,
+      position: index.snapshot(this.position),
+      status: index.snapshot(this.status),
+      canceled: this.canceled
+    }));
+  }
+  /**
+   * Resets the drag operation to its initial state.
+   *
+   * @remarks
+   * This method:
+   * - Sets status to idle
+   * - Clears source and target identifiers
+   * - Resets shape history
+   * - Resets position and transform
+   * - Clears modifiers
+   */
+  reset() {
+    signalsCore.batch(() => {
+      this.status.set("idle" /* Idle */);
+      this.sourceIdentifier = null;
+      this.targetIdentifier = null;
+      __privateGet(this, _shape2).reset();
+      this.position.reset({ x: 0, y: 0 });
+      __privateSet(this, _transform, { x: 0, y: 0 });
+      this.modifiers = [];
+    });
+  }
+};
+_init6 = __decoratorStart(null);
+_manager2 = new WeakMap();
+_previousSource = new WeakMap();
+_shape2 = new WeakMap();
+_canceled = new WeakMap();
+_activatorEvent = new WeakMap();
+_sourceIdentifier = new WeakMap();
+_targetIdentifier = new WeakMap();
+_modifiers2 = new WeakMap();
+_transform = new WeakMap();
+__decorateElement(_init6, 2, "shape", _shape_dec2, DragOperation);
+__decorateElement(_init6, 4, "canceled", _canceled_dec, DragOperation, _canceled);
+__decorateElement(_init6, 4, "activatorEvent", _activatorEvent_dec, DragOperation, _activatorEvent);
+__decorateElement(_init6, 4, "sourceIdentifier", _sourceIdentifier_dec, DragOperation, _sourceIdentifier);
+__decorateElement(_init6, 4, "targetIdentifier", _targetIdentifier_dec, DragOperation, _targetIdentifier);
+__decorateElement(_init6, 4, "modifiers", _modifiers_dec2, DragOperation, _modifiers2);
+__decorateElement(_init6, 2, "source", _source_dec, DragOperation);
+__decorateElement(_init6, 2, "target", _target_dec, DragOperation);
+__decorateElement(_init6, 2, "transform", _transform_dec, DragOperation);
+__decoratorMetadata(_init6, DragOperation);
+
+exports.CollisionPriority = CollisionPriority;
+exports.CollisionType = CollisionType;
+exports.CorePlugin = CorePlugin;
+exports.DragOperationStatus = Status;
+exports.Draggable = Draggable$1;
+exports.Droppable = Droppable$1;
+exports.Plugin = Plugin;
+exports.Sensor = Sensor;
+exports.configurator = configurator;
+exports.configure = configure;
+exports.descriptor = descriptor;
+//# sourceMappingURL=index.js.map