katalyst-tables 2.2.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc97f1a686a28e4542c65f076afde15d61523726efb4dcaa3586e6c945121c13
-  data.tar.gz: 10eee025b9e0daee5d3aeda7a78625e6491d91d02f99bf831092072845276185
+  metadata.gz: 6b8413e971a3164d1ab1fa688a20ce34e1f25768da7650565d9f600e1612a80e
+  data.tar.gz: d14455c86030073e293aafbaaf86a4da483be27912cca5a8d46cc43cc3a532b8
 SHA512:
-  metadata.gz: 2a7e06d525551918f60e7b9a225f4ddb34bb3eeaeaecde37e817d0c61ade348f52e290235b21e84bedc72c92615f81e1226a10305242ff3e95e33fbb47a21878
-  data.tar.gz: 2d23b372c056506b054c02165e7191eb73d00f76df054e0d70eafbd88d6979126a3803c11bef29889f9095f644c7e40b30396da8d48580239978a7c9ee795019
+  metadata.gz: 5825f4058bc40aa823dbdd0719d8738a5fa4e4738442438c7e0c86ae9942cb5fc163d19b7754eb27b1abd061699dccfd79b249c93ceef8ce3605c101a4262522
+  data.tar.gz: ed4ccfa22d6342eff7c6f0a84ac6c28472263c249846594d794492c40c2b2a8bd9265f26fe897cb5a331c489b2b2d5caf59da98619ad16763a8a4dd4e8124f05

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, index) {
+    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="${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,10 @@ import { Controller } from "@hotwired/stimulus";
 
 export default class OrderableRowController extends Controller {
   static values = {
-    name: String,
-    value: Number,
+    params: Object,
   };
+
+  get index() {
+    return this.paramsValue.index_value;
+  }
 }

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

@@ -41,8 +41,8 @@ export default class OrderableListController extends Controller {
 
     // insert any items that have changed position
     this.tablesOrderableItemOutlets.forEach((item, index) => {
-      if (item.valueValue !== index) {
-        this.tablesOrderableFormOutlet.add(item.nameValue, index);
+      if (item.index !== index) {
+        this.tablesOrderableFormOutlet.add(item, index);
       }
     });
 

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,28 +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)
-        # Add `orderable` columns to row components
-        table_class.header_row_component.include(HeaderRow)
-        table_class.body_row_component.include(BodyRow)
-
+      # 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
+
+        # ensure row components support orderable column calls
+        add_orderable_columns
       end
 
       def tbody_attributes
@@ -53,6 +55,31 @@ module Katalyst
         )
       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: "")
@@ -60,13 +87,17 @@ 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)
+        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", data: {
-                 controller: ITEM_CONTROLLER,
-                 "#{ITEM_CONTROLLER}-name-value" => name,
-                 "#{ITEM_CONTROLLER}-value-value" => value,
+                 controller:                        ITEM_CONTROLLER,
+                 "#{ITEM_CONTROLLER}-params-value": params.to_json,
                }) { t("katalyst.tables.orderable.value") }
         end
 
@@ -94,8 +125,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/app/models/concerns/katalyst/tables/collection/core.rb

@@ -16,7 +16,7 @@ module Katalyst
         included do
           attr_accessor :items
 
-          delegate :model, :to_model, :each, :count, :empty?, to: :items, allow_nil: true
+          delegate :model, :each, :count, :empty?, to: :items, allow_nil: true
           delegate :model_name, to: :model, allow_nil: true
         end
 

data/lib/katalyst/tables/version.rb

@@ -2,6 +2,6 @@
 
 module Katalyst
   module Tables
-    VERSION = "2.2.0"
+    VERSION = "2.2.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Katalyst Interactive