toolshed-8.x-1.x-dev/js/DragDrop.js

"use strict";

(({
  Toolshed
}) => {
  /**
   * Object wrapping a DOM element to implement a droppable container for
   * accepting draggable instances.
   */
  class Droppable {
    /**
     * Create a new instance of a droppable for containing draggables.
     *
     * @param {Element} el
     *   DOM element to treat as the droppable.
     * @param {Object} opts
     *   Configuration options to control how this droppable behaves.
     */
    constructor(el, opts = {}) {
      this.el = el;
      this.opts = {
        ...opts
      };
      this.id = el.dataset.containerId;
      this.items = [];
      this.children = [];
    }
    getId() {
      return this.id;
    }
    getItems() {
      return this.items;
    }
    getChildren() {
      return this.children;
    }
    attachItem(item, pos) {
      const el = item.getElement();
      if ((pos || pos === 0) && this.items.length > pos) {
        this.el.insertBefore(el, this.items[pos].getElement());
        this.items.splice(pos, 0, el);
      } else {
        this.el.appendChild(item.getElement());
        this.items.push(item);
        pos = this.items.length - 1;
      }
      item.attach(this, pos);
    }
    detachItem(item) {
      for (let i = 0; i < this.items.length; ++i) {
        if (this.items[i] === item) {
          this.items.splice(i, 1);
          break;
        }
      }
      this.el.removeChild(item.getElement());
      item.detach();
    }
  }

  /**
   * A element that is draggable and can get placed into {Droppable} objects.
   */
  class Draggable {
    /**
     * Get the active dragging object instance, if there is a dragging action
     * in progress. There will only be a single draggable actively being dragged
     * at any given time.
     *
     * @return {Draggable|null}
     *   Return the draggable instance if there is one, otherwise return {null}.
     */
    static get dragging() {
      return this._dragging;
    }

    /**
     * Get the currently active dragging tracking to this draggable object.
     * This property is global because there should only be 1 active dragging
     * activity for the entire application, even if it is accross multiple
     * drag and drop sets.
     *
     * @param {Draggable|null} draggable
     *   Set the {Draggable} element as actively being dragged. Passing {null}
     *   as the parameter here is the same as unsetting cancelling any current
     *   dragging activity and clearing this property.
     */
    static set dragging(draggable) {
      if (this._dragging) {
        const oldDrag = this._dragging;
        oldDrag.cancelDrag(false);
      }
      this._dragging = draggable;
    }

    /**
     * Construct a new draggable handler.
     *
     * @param {Element} el
     *   The element to attach the draggable behaviors to.
     * @param {Object} opts
     *   The options for the draggable behaviors.
     */
    constructor(el, opts = {}) {
      this.el = el;
      this.opts = {
        inputSelector: 'input.drag-parent',
        ...opts
      };
      this.parent = null;
      this.pos = 0;
      this.input = this.el.querySelector(this.opts.inputSelector);
    }
    getElement() {
      return this.el;
    }
    attach(droppable, pos) {
      this.parent = droppable;
      this.pos = pos;
      this.input.value = `${droppable.getId()}:${pos}`;
    }
    detach() {
      this.parent = null;
      this.pos = 0;
      this.input.value = '';
    }

    /**
     * Cancel the dragging action if it's been dragged.
     */
    cancelDrag() {
      if (this.placeholder) {
        this.placeholder.parentNode.removeChild(this.placeholder);
      }
    }
  }

  // Export the drag and drop definitions to the Toolshed namespace.
  Toolshed.Droppable = Droppable;
  Toolshed.Draggable = Draggable;
})(Drupal);
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"DragDrop.js","names":["Toolshed","Droppable","constructor","el","opts","id","dataset","containerId","items","children","getId","getItems","getChildren","attachItem","item","pos","getElement","length","insertBefore","splice","appendChild","push","attach","detachItem","i","removeChild","detach","Draggable","dragging","_dragging","draggable","oldDrag","cancelDrag","inputSelector","parent","input","querySelector","droppable","value","placeholder","parentNode","Drupal"],"sources":["DragDrop.es6.js"],"sourcesContent":["(({ Toolshed }) => {\n  /**\n   * Object wrapping a DOM element to implement a droppable container for\n   * accepting draggable instances.\n   */\n  class Droppable {\n    /**\n     * Create a new instance of a droppable for containing draggables.\n     *\n     * @param {Element} el\n     *   DOM element to treat as the droppable.\n     * @param {Object} opts\n     *   Configuration options to control how this droppable behaves.\n     */\n    constructor(el, opts = {}) {\n      this.el = el;\n      this.opts = {\n        ...opts,\n      };\n\n      this.id = el.dataset.containerId;\n      this.items = [];\n      this.children = [];\n    }\n\n    getId() {\n      return this.id;\n    }\n\n    getItems() {\n      return this.items;\n    }\n\n    getChildren() {\n      return this.children;\n    }\n\n    attachItem(item, pos) {\n      const el = item.getElement();\n\n      if ((pos || pos === 0) && this.items.length > pos) {\n        this.el.insertBefore(el, this.items[pos].getElement());\n        this.items.splice(pos, 0, el);\n      }\n      else {\n        this.el.appendChild(item.getElement());\n        this.items.push(item);\n        pos = this.items.length - 1;\n      }\n\n      item.attach(this, pos);\n    }\n\n    detachItem(item) {\n      for (let i = 0; i < this.items.length; ++i) {\n        if (this.items[i] === item) {\n          this.items.splice(i, 1);\n          break;\n        }\n      }\n\n      this.el.removeChild(item.getElement());\n      item.detach();\n    }\n  }\n\n  /**\n   * A element that is draggable and can get placed into {Droppable} objects.\n   */\n  class Draggable {\n    /**\n     * Get the active dragging object instance, if there is a dragging action\n     * in progress. There will only be a single draggable actively being dragged\n     * at any given time.\n     *\n     * @return {Draggable|null}\n     *   Return the draggable instance if there is one, otherwise return {null}.\n     */\n    static get dragging() {\n      return this._dragging;\n    }\n\n    /**\n     * Get the currently active dragging tracking to this draggable object.\n     * This property is global because there should only be 1 active dragging\n     * activity for the entire application, even if it is accross multiple\n     * drag and drop sets.\n     *\n     * @param {Draggable|null} draggable\n     *   Set the {Draggable} element as actively being dragged. Passing {null}\n     *   as the parameter here is the same as unsetting cancelling any current\n     *   dragging activity and clearing this property.\n     */\n    static set dragging(draggable) {\n      if (this._dragging) {\n        const oldDrag = this._dragging;\n\n        oldDrag.cancelDrag(false);\n      }\n\n      this._dragging = draggable;\n    }\n\n    /**\n     * Construct a new draggable handler.\n     *\n     * @param {Element} el\n     *   The element to attach the draggable behaviors to.\n     * @param {Object} opts\n     *   The options for the draggable behaviors.\n     */\n    constructor(el, opts = {}) {\n      this.el = el;\n      this.opts = {\n        inputSelector: 'input.drag-parent',\n        ...opts,\n      };\n\n      this.parent = null;\n      this.pos = 0;\n      this.input = this.el.querySelector(this.opts.inputSelector);\n    }\n\n    getElement() {\n      return this.el;\n    }\n\n    attach(droppable, pos) {\n      this.parent = droppable;\n      this.pos = pos;\n      this.input.value = `${droppable.getId()}:${pos}`;\n    }\n\n    detach() {\n      this.parent = null;\n      this.pos = 0;\n      this.input.value = '';\n    }\n\n    /**\n     * Cancel the dragging action if it's been dragged.\n     */\n    cancelDrag() {\n      if (this.placeholder) {\n        this.placeholder.parentNode.removeChild(this.placeholder);\n      }\n    }\n  }\n\n  // Export the drag and drop definitions to the Toolshed namespace.\n  Toolshed.Droppable = Droppable;\n  Toolshed.Draggable = Draggable;\n})(Drupal);\n"],"mappings":"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"}