katalyst-tables 2.2.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187059d630f338d5bcdd0ecc98eb3850fa7d4d01e6d37f0918143873c7a50033
-  data.tar.gz: ac469214c3cdcf72b97ec5e5ab973356307d4d218d13face3ed48a82f9c09035
+  metadata.gz: 8224ebb910f428c3f7750ae6e79c92f21440f5546a2baaede473bb286f217a82
+  data.tar.gz: 6be02c8a263dda22b7faae734cb20e8cec5879db532adb50f257bd502fa51265
 SHA512:
-  metadata.gz: 0a134c643f8780ff95287de876492b356adaa0e822b4fd72afe68980135859813cc5e9a1ac0c391bb227b27bc597a32c79266c1c88afcd005cc3186c3c30e27c
-  data.tar.gz: 5eb871b2122d8edd2e95724f52d8a073ff4109e8281aadb1b7e8df231dd1f00d1096de80af370f8a3a6b42bfa8b9025254e29e2e16fb18ccc488c56222bee61e
+  metadata.gz: 61052d361a93ab2675274f9ed3b3f59e0acd08519261cf016c4db55006097d72f78114ba489e5eed9d066a82aa6bbaa9dd00675d378e24c996a5ccba775bce75
+  data.tar.gz: e411c014472cd5d34338ad0a02d869d69352fd4c6abe70c68ead05d75b3d2f0f52bf11c263031cd6606d27d09c7565e76770eee0b9149b58ef5e91ec383d86bf

data/app/assets/javascripts/controllers/tables/orderable/form_controller.js

@@ -1,20 +1,26 @@
 import { Controller } from "@hotwired/stimulus";
 
 export default class OrderableFormController extends Controller {
-  add(name, value) {
+  add(item) {
+    const { id_name, id_value, index_name } = item.paramsValue;
     this.element.insertAdjacentHTML(
       "beforeend",
-      `<input type="hidden" name="${name}" value="${value}" data-generated>`,
+      `<input type="hidden" name="${id_name}" value="${id_value}" data-generated>
+              <input type="hidden" name="${index_name}" value="${item.index}" data-generated>`,
     );
   }
 
   submit() {
+    if (this.inputs.length === 0) return;
+
     this.element.requestSubmit();
   }
 
   clear() {
-    this.element
-      .querySelectorAll("input[data-generated]")
-      .forEach((input) => input.remove());
+    this.inputs.forEach((input) => input.remove());
+  }
+
+  get inputs() {
+    return this.element.querySelectorAll("input[data-generated]");
   }
 }

data/app/assets/javascripts/controllers/tables/orderable/item_controller.js

@@ -2,7 +2,99 @@ import { Controller } from "@hotwired/stimulus";
 
 export default class OrderableRowController extends Controller {
   static values = {
-    name: String,
-    value: Number,
+    params: Object,
   };
+
+  paramsValueChanged(params) {
+    this.id = params.id_value;
+    this.index = params.index_value;
+  }
+
+  dragUpdate(offset) {
+    this.dragOffset = offset;
+    this.row.style.position = "relative";
+    this.row.style.top = offset + "px";
+    this.row.style.zIndex = 1;
+    this.row.toggleAttribute("dragging", true);
+  }
+
+  /**
+   * Called on items that are not the dragged item during drag. Updates the
+   * visual position of the item relative to the dragged item.
+   *
+   * @param index {number} intended index of the item during drag
+   */
+  updateVisually(index) {
+    this.row.style.position = "relative";
+    this.row.style.top = `${
+      this.row.offsetHeight * (index - this.dragIndex)
+    }px`;
+  }
+
+  /**
+   * Set the index value of the item. This is called on all items after a drop
+   * event. If the index is different to the params index then this item has
+   * changed.
+   *
+   * @param index {number} the new index value
+   */
+  updateIndex(index) {
+    this.index = index;
+  }
+
+  /**
+   * Restore any visual changes made during drag and remove the drag state.
+   */
+  reset() {
+    delete this.dragOffset;
+    this.row.removeAttribute("style");
+    this.row.removeAttribute("dragging");
+  }
+
+  /**
+   * @returns {boolean} true when the item has a change to its index value
+   */
+  get hasChanges() {
+    return this.paramsValue.index_value !== this.index;
+  }
+
+  /**
+   * Calculate the relative index of the item during drag. This is used to
+   * sort items during drag as it takes into account any uncommitted changes
+   * to index caused by the drag offset.
+   *
+   * @returns {number} index for the purposes of drag and drop ordering
+   */
+  get dragIndex() {
+    if (this.dragOffset && this.dragOffset !== 0) {
+      return this.index + Math.round(this.dragOffset / this.row.offsetHeight);
+    } else {
+      return this.index;
+    }
+  }
+
+  /**
+   * Index value for use in comparisons during drag. This is used to determine
+   * whether the dragged item is above or below another item. If this item is
+   * being dragged then we offset the index by 0.5 to ensure that it jumps up
+   * or down when it reaches the midpoint of the item above or below it.
+   *
+   * @returns {number}
+   */
+  get comparisonIndex() {
+    if (this.dragOffset) {
+      return this.dragIndex + (this.dragOffset > 0 ? 0.5 : -0.5);
+    } else {
+      return this.index;
+    }
+  }
+
+  /**
+   * The containing row element.
+   *
+   * @returns {HTMLElement}
+   */
+  get row() {
+    return this.element.parentElement;
+  }
 }

data/app/assets/javascripts/controllers/tables/orderable/list_controller.js

@@ -3,71 +3,245 @@ import { Controller } from "@hotwired/stimulus";
 export default class OrderableListController extends Controller {
   static outlets = ["tables--orderable--item", "tables--orderable--form"];
 
-  dragstart(event) {
-    if (this.element !== event.target.parentElement) return;
+  //region State transitions
 
-    const target = event.target;
-    event.dataTransfer.effectAllowed = "move";
+  startDragging(dragState) {
+    this.dragState = dragState;
 
-    // update element style after drag has begun
-    setTimeout(() => (target.dataset.dragging = ""));
+    document.addEventListener("mousemove", this.mousemove);
+    document.addEventListener("mouseup", this.mouseup);
+
+    this.element.style.position = "relative";
   }
 
-  dragover(event) {
-    if (!this.dragItem) return;
+  stopDragging() {
+    const dragState = this.dragState;
+    delete this.dragState;
 
-    swap(this.dropTarget(event.target), this.dragItem);
+    document.removeEventListener("mousemove", this.mousemove);
+    document.removeEventListener("mouseup", this.mouseup);
 
-    event.preventDefault();
-    return true;
-  }
+    this.element.removeAttribute("style");
+    this.tablesOrderableItemOutlets.forEach((item) => item.reset());
 
-  dragenter(event) {
-    event.preventDefault();
+    return dragState;
   }
 
-  drop(event) {
-    if (!this.dragItem) return;
+  drop() {
+    // note: early returns guard against turbo updates that prevent us finding
+    // the right item to drop on. In this situation it's better to discard the
+    // drop than to drop in the wrong place.
+
+    const dragItem = this.dragItem;
+
+    if (!dragItem) return;
+
+    const newIndex = dragItem.dragIndex;
+    const targetItem = this.tablesOrderableItemOutlets[newIndex];
+
+    if (!targetItem) return;
 
-    event.preventDefault();
-    delete this.dragItem.dataset.dragging;
+    // swap the dragged item into the correct position for its current offset
+    if (newIndex < dragItem.index) {
+      targetItem.row.insertAdjacentElement("beforebegin", dragItem.row);
+    } else if (newIndex > dragItem.index) {
+      targetItem.row.insertAdjacentElement("afterend", dragItem.row);
+    }
+
+    // reindex all items based on their new positions
+    this.tablesOrderableItemOutlets.forEach((item, index) =>
+      item.updateIndex(index),
+    );
 
-    this.update();
+    // save the changes
+    this.commitChanges();
   }
 
-  update() {
+  commitChanges() {
     // clear any existing inputs to prevent duplicates
     this.tablesOrderableFormOutlet.clear();
 
     // insert any items that have changed position
-    this.tablesOrderableItemOutlets.forEach((item, index) => {
-      if (item.valueValue !== index) {
-        this.tablesOrderableFormOutlet.add(item.nameValue, index);
-      }
+    this.tablesOrderableItemOutlets.forEach((item) => {
+      if (item.hasChanges) this.tablesOrderableFormOutlet.add(item);
     });
 
     this.tablesOrderableFormOutlet.submit();
   }
 
-  get dragItem() {
-    return this.element.querySelector("[data-dragging]");
+  //endregion
+
+  //region Events
+
+  mousedown(event) {
+    if (this.isDragging) return;
+
+    const target = this.#targetItem(event.target);
+
+    if (!target) return;
+
+    event.preventDefault(); // prevent built-in drag
+
+    this.startDragging(new DragState(this.element, event, target.id));
+
+    this.#updateDragItem(event);
   }
 
-  dropTarget($e) {
-    while ($e && $e.parentElement !== this.element) {
-      $e = $e.parentElement;
+  mousemove = (event) => {
+    if (!this.isDragging) return;
+
+    event.preventDefault(); // prevent build-in drag
+
+    const dragItem = this.#updateDragItem(event);
+
+    // Visually updates the position of all items in the list relative to the
+    // dragged item. No actual changes to orderings at this stage.
+    this.#currentItems.forEach((item, index) => {
+      if (item === dragItem) return;
+      item.updateVisually(index);
+    });
+  };
+
+  mouseup = (event) => {
+    if (!this.isDragging) return;
+
+    this.drop();
+    this.stopDragging();
+    this.tablesOrderableFormOutlets.forEach((form) => delete form.dragState);
+  };
+
+  tablesOrderableFormOutletConnected(form, element) {
+    if (form.dragState) {
+      // restore the previous controller's state
+      this.startDragging(form.dragState);
     }
-    return $e;
   }
+
+  tablesOrderableFormOutletDisconnected(form, element) {
+    if (this.isDragging) {
+      // cache drag state in the form
+      form.dragState = this.stopDragging();
+    }
+  }
+
+  //endregion
+
+  //region Helpers
+
+  get isDragging() {
+    return !!this.dragState;
+  }
+
+  get dragItem() {
+    if (!this.isDragging) return null;
+
+    return this.tablesOrderableItemOutlets.find(
+      (item) => item.id === this.dragState.targetId,
+    );
+  }
+
+  /**
+   * Returns the current items in the list, sorted by their current index.
+   * Current uses the drag index if the item is being dragged, if set.
+   *
+   * @returns {Array[OrderableRowController]}
+   */
+  get #currentItems() {
+    return this.tablesOrderableItemOutlets.toSorted(
+      (a, b) => a.comparisonIndex - b.comparisonIndex,
+    );
+  }
+
+  /**
+   * Returns the item outlet that was clicked on, if any.
+   *
+   * @param event {HTMLElement} the clicked ordinal cell
+   * @returns {OrderableRowController}
+   */
+  #targetItem(element) {
+    return this.tablesOrderableItemOutlets.find(
+      (item) => item.element === element,
+    );
+  }
+
+  #updateDragItem(event) {
+    const offset = this.dragState.itemOffset(
+      this.element,
+      this.dragItem.row,
+      event,
+    );
+    const item = this.dragItem;
+    item.dragUpdate(offset);
+    return item;
+  }
+
+  //endregion
 }
 
-function swap(target, item) {
-  if (target && target !== item) {
-    const positionComparison = target.compareDocumentPosition(item);
-    if (positionComparison & Node.DOCUMENT_POSITION_FOLLOWING) {
-      target.insertAdjacentElement("beforebegin", item);
-    } else if (positionComparison & Node.DOCUMENT_POSITION_PRECEDING) {
-      target.insertAdjacentElement("afterend", item);
+/**
+ * During drag we want to be able to translate a document-relative coordinate
+ * into a coordinate relative to the list element. This state object calculates
+ * and stores internal state so that we can translate absolute page coordinates
+ * from mouse events into relative offsets for the list items within the list
+ * element.
+ *
+ * We also keep track of the drag target so that if the controller is attached
+ * to a new element during the drag we can continue after the turbo update.
+ */
+class DragState {
+  /**
+   * @param list {HTMLElement} the list controller's element (tbody)
+   * @param event {MouseEvent} the initial event
+   * @param id {String} the id of the element being dragged
+   */
+  constructor(list, event, id) {
+    // calculate the offset top of the tbody element relative to offsetParent
+    const offsetParent = list.offsetParent;
+    let offsetTop = event.offsetY;
+    let current = event.target;
+    while (current && current !== offsetParent) {
+      offsetTop += current.offsetTop;
+      current = current.offsetParent;
     }
+
+    // page offset is the offset of the tbody element relative to the page
+    this.pageOffset = event.pageY - offsetTop + list.offsetTop;
+
+    // cursor offset is the offset of the cursor relative to the drag item
+    this.cursorOffset = event.offsetY;
+
+    // initial offset is the offset position of the drag item at drag start
+    this.initialOffset = event.target.offsetTop - list.offsetTop;
+
+    // id of the item being dragged
+    this.targetId = id;
+  }
+
+  /**
+   * Calculates the offset of the drag item relative to its initial position.
+   *
+   * @param list {HTMLElement} the list controller's element (tbody)
+   * @param row {HTMLElement} the row being dragged
+   * @param event {MouseEvent} the current event
+   * @returns {number} relative offset for the item being dragged
+   */
+  itemOffset(list, row, event) {
+    // cursor position relative to the list
+    const cursorPosition = event.pageY - this.pageOffset;
+
+    // item position relative to the list
+    let itemPosition = cursorPosition - this.cursorOffset;
+
+    // ensure itemPosition is within the bounds of the list (tbody)
+    itemPosition = Math.max(itemPosition, 0);
+    itemPosition = Math.min(itemPosition, list.offsetHeight - row.offsetHeight);
+
+    // Item has position: relative, so we want to calculate the amount to move
+    // the item relative to it's DOM position to represent how much it has been
+    // dragged by.
+
+    // Convert itemPosition from offset relative to list to offset relative to
+    // its position within the DOM (if it hadn't moved).
+    return itemPosition - this.initialOffset;
   }
 }

data/app/components/concerns/katalyst/tables/has_table_content.rb

@@ -26,7 +26,7 @@ module Katalyst
       def row_partial(row, record = nil)
         partial = @partial || model_name&.param_key&.to_s
         as      = @as || model_name&.param_key&.to_sym
-        render(partial: partial, variants: [:row], locals: { as => record, row: row })
+        render(partial: partial, variants: [:row], formats: [:html], locals: { as => record, row: row })
       end
     end
   end

data/app/components/concerns/katalyst/tables/orderable.rb

@@ -13,32 +13,30 @@ module Katalyst
 
       using HasHtmlAttributes
 
-      # Enhance a given table component class with orderable support.
-      # Supports extension via `included` and `extended` hooks.
-      def self.make_orderable(table_class)
+      # Support for inclusion in a table component class
+      # Adds an `orderable` slot and component configuration
+      included do
         # Add `orderable` slot to table component
-        table_class.config_component :orderable, default: "FormComponent"
-        table_class.renders_one(:orderable, lambda do |**attrs|
+        config_component :orderable, default: "Katalyst::Tables::Orderable::FormComponent"
+        renders_one(:orderable, lambda do |**attrs|
           orderable_component.new(table: self, **attrs)
         end)
       end
 
-      # Support for inclusion in a table component class
-      included do
-        Orderable.make_orderable(self)
-      end
-
       # Support for extending a table component instance
+      # Adds methods to the table component instance
       def self.extended(table)
-        Orderable.make_orderable(table.class)
+        table.extend(TableMethods)
+
+        # ensure row components support orderable column calls
+        table.send(:add_orderable_columns)
       end
 
       def initialize(**attributes)
         super
 
-        # Add `orderable` columns to row components
-        header_row_component.include(HeaderRow)
-        body_row_component.include(BodyRow)
+        # ensure row components support orderable column calls
+        add_orderable_columns
       end
 
       def tbody_attributes
@@ -47,16 +45,38 @@ module Katalyst
         super.merge_html(
           { data: { controller: LIST_CONTROLLER,
                     action: <<~ACTIONS.squish,
-                      dragstart->#{LIST_CONTROLLER}#dragstart
-                      dragenter->#{LIST_CONTROLLER}#dragenter
-                      dragover->#{LIST_CONTROLLER}#dragover
-                      drop->#{LIST_CONTROLLER}#drop
+                      mousedown->#{LIST_CONTROLLER}#mousedown
                     ACTIONS
                     "#{LIST_CONTROLLER}-#{FORM_CONTROLLER}-outlet" => "##{orderable.id}",
                     "#{LIST_CONTROLLER}-#{ITEM_CONTROLLER}-outlet" => "td.ordinal" } },
         )
       end
 
+      private
+
+      # Add `orderable` columns to row components
+      def add_orderable_columns
+        header_row_component.include(HeaderRow)
+        body_row_component.include(BodyRow)
+      end
+
+      # Methods required to emulate a slot when extending an existing table.
+      module TableMethods
+        def with_orderable(**attrs)
+          @orderable = FormComponent.new(table: self, **attrs)
+
+          self
+        end
+
+        def orderable?
+          @orderable.present?
+        end
+
+        def orderable
+          @orderable
+        end
+      end
+
       module HeaderRow # :nodoc:
         def ordinal(attribute = :ordinal, **)
           cell(attribute, class: "ordinal", label: "")
@@ -64,23 +84,19 @@ module Katalyst
       end
 
       module BodyRow # :nodoc:
-        def ordinal(attribute = :ordinal, id: :id)
-          name  = @table.orderable.record_scope(@record, id, attribute)
-          value = @record.public_send(attribute)
-          cell(attribute, class: "ordinal", data: {
-                 controller: ITEM_CONTROLLER,
-                 "#{ITEM_CONTROLLER}-name-value" => name,
-                 "#{ITEM_CONTROLLER}-value-value" => value,
+        def ordinal(attribute = :ordinal, primary_key: :id)
+          id = @record.public_send(primary_key)
+          params = {
+            id_name:     @table.orderable.record_scope(id, primary_key),
+            id_value:    id,
+            index_name:  @table.orderable.record_scope(id, attribute),
+            index_value: @record.public_send(attribute),
+          }
+          cell(attribute, class: "ordinal", draggable: true, data: {
+                 controller:                        ITEM_CONTROLLER,
+                 "#{ITEM_CONTROLLER}-params-value": params.to_json,
                }) { t("katalyst.tables.orderable.value") }
         end
-
-        def html_attributes
-          super.merge_html(
-            {
-              draggable: "true",
-            },
-          )
-        end
       end
 
       class FormComponent < ViewComponent::Base # :nodoc:
@@ -98,8 +114,8 @@ module Katalyst
           @scope = scope
         end
 
-        def record_scope(record, id, attribute)
-          "#{scope}[#{record.public_send(id)}][#{attribute}]"
+        def record_scope(id, attribute)
+          "#{scope}[#{id}][#{attribute}]"
         end
 
         def call

data/app/components/concerns/katalyst/tables/turbo_replaceable.rb

@@ -13,10 +13,16 @@ module Katalyst
 
       include ::Turbo::StreamsHelper
 
+      # Is turbo rendering enabled for this component?
       def turbo?
         @turbo
       end
 
+      # Are we rendering a turbo stream response?
+      def turbo_stream_response?
+        response.media_type.eql?("text/vnd.turbo-stream.html")
+      end
+
       def initialize(turbo: true, **options)
         super(**options)
 
@@ -44,16 +50,27 @@ module Katalyst
           super
 
           redefinition_lock.synchronize do
-            component_class.alias_method(:vc_render_template_for, :render_template_for)
-            component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def render_template_for(variant = nil)
-              if turbo? && response.media_type.eql?("text/vnd.turbo-stream.html")
-                turbo_stream.replace(id, vc_render_template_for(variant))
+            # Capture the instance method added by the default compiler and
+            # wrap it in a turbo stream replacement. Take care to ensure that
+            # subclasses of this component don't break delegation, as each
+            # subclass of ViewComponent::Base defines its own version of this
+            # method.
+            vc_render_template = component_class.instance_method(:render_template_for)
+            component_class.define_method(:render_template_for) do |variant = nil|
+              # VC discards the output from this method and uses the buffer
+              # if both are set. Capture and wrap the output.
+              content = capture { vc_render_template.bind_call(self, variant) }
+              # In turbo mode, replace the inner-most element using a turbo
+              # stream. Note that we only want one turbo stream per component
+              # from this mechanism, as subclasses may want to concat their
+              # own additional streams.
+              if turbo? && turbo_stream_response? && !@streamed
+                @streamed = true
+                concat(turbo_stream.replace(id, content))
               else
-                vc_render_template_for(variant)
+                concat(content)
               end
             end
-            RUBY
           end
         end
       end

data/app/components/katalyst/turbo/table_component.rb

@@ -7,6 +7,8 @@ module Katalyst
     class TableComponent < ::Katalyst::TableComponent
       include Tables::TurboReplaceable
 
+      attr_reader :id
+
       def initialize(collection:, id:, header: true, **options)
         header = if header.is_a?(Hash)
                    default_header_options.merge(header)
@@ -14,11 +16,9 @@ module Katalyst
                    default_header_options
                  end
 
-        super(collection: collection, header: header, id: id, **options)
-      end
+        @id = id
 
-      def id
-        html_attributes[:id]
+        super(collection: collection, header: header, id: id, **options)
       end
 
       private

data/lib/katalyst/tables/version.rb

@@ -2,6 +2,6 @@
 
 module Katalyst
   module Tables
-    VERSION = "2.2.1"
+    VERSION = "2.2.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.3
 platform: ruby
 authors:
 - Katalyst Interactive
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-20 00:00:00.000000000 Z
+date: 2023-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: html-attributes-utils