nitro_kit 0.9.0 → 2.0.0.alpha.2

data/app/components/nitro_kit/tabs.rb

@@ -2,103 +2,208 @@
 
 module NitroKit
   class Tabs < Component
-    def initialize(default: nil, **attrs)
-      @default = default
-      @id = attrs[:id] || SecureRandom.hex(6)
+    ORIENTATIONS = %i[horizontal vertical].freeze
+    ACTIVATIONS = %i[automatic manual].freeze
+    Tab = ::Data.define(:key, :label, :disabled, :content)
+
+    def initialize(
+      default: nil,
+      id:,
+      label: I18n.t("nitro_kit.tabs.label"),
+      orientation: :horizontal,
+      activation: :automatic,
+      html: {},
+      aria: {},
+      data: {},
+      desperately_need_a_class: nil
+    )
+      @identifier = component_id(id)
+      @default = default.nil? ? nil : normalize_identity(default, name: "default tab key")
+      @label = validate_label!(label)
+      @orientation = validate_choice!(:orientation, orientation, ORIENTATIONS)
+      @activation = validate_choice!(:activation, activation, ACTIVATIONS)
+      @tabs = []
 
       super(
-        attrs,
-        data: { controller: "nk--tabs", nk__tabs_active_value: default },
-        class: base_class
+        component: :tabs,
+        attributes: {
+          id: @identifier,
+          data: {
+            controller: "nk--tabs",
+            orientation: @orientation,
+            activation: @activation,
+            nk__tabs_active_value: @default || "",
+            nk__tabs_orientation_value: @orientation,
+            nk__tabs_activation_value: @activation
+          }
+        },
+        html:,
+        aria:,
+        data:,
+        desperately_need_a_class:
       )
     end
 
-    attr_reader :default, :id
+    attr_reader :identifier, :default, :label, :orientation, :activation
+
+    def view_template(&block)
+      collect_tabs(&block)
+      active_key = resolve_active_key
 
-    def view_template
-      div(**attrs) do
-        yield
+      div(**root_attributes_for(active_key)) do
+        render_tablist(active_key)
+        @tabs.each { |tab| render_panel(tab, active_key:) }
       end
     end
 
-    def tabs(**attrs)
-      builder do
-        div(**mattr, role: "tabtabs", class: tabs_class) do
-          yield
-        end
+    def tab(key, label, disabled: false, &content)
+      ensure_collecting!
+
+      key = normalize_identity(key, name: "tab key")
+      label = validate_label!(label)
+      disabled = validate_boolean!(:disabled, disabled)
+      raise ArgumentError, "Tab #{key.inspect} requires panel content" unless content
+      raise ArgumentError, "Duplicate tab key #{key.inspect}" if find_tab(key)
+
+      @tabs << Tab.new(key:, label:, disabled:, content:)
+      nil
+    end
+
+    private
+
+    def collect_tabs
+      raise ArgumentError, "Tabs requires a tab declaration block" unless block_given?
+
+      @collecting = true
+      yield(self)
+      raise ArgumentError, "Tabs requires at least one tab" if @tabs.empty?
+    ensure
+      @collecting = false
+    end
+
+    def render_tablist(active_key)
+      div(
+        **slot_attributes(
+          :list,
+          attributes: {
+            role: "tablist",
+            aria: {
+              label:,
+              orientation:
+            }
+          }
+        )
+      ) do
+        @tabs.each { |tab| render_tab(tab, active_key:) }
       end
     end
 
-    def tab(key, text = nil, **attrs, &block)
-      builder do
-        button(
-          **mattr(
-            attrs,
+    def render_tab(tab, active_key:)
+      active = tab.key == active_key
+
+      button(
+        **slot_attributes(
+          :tab,
+          attributes: {
+            id: tab_id(tab),
+            type: "button",
+            role: "tab",
+            disabled: tab.disabled,
+            tabindex: tab.disabled ? -1 : 0,
             aria: {
-              selected: (default == key).to_s,
-              controls: tab_id(key, :panel)
+              controls: panel_id(tab),
+              selected: active
             },
-            class: tab_class,
             data: {
-              action: "nk--tabs#setActiveTab keydown.left->nk--tabs#prevTab keydown.right->nk--tabs#nextTab",
-              key:,
-              nk__tabs_key_param: key,
+              key: tab.key,
+              state: active ? "active" : "inactive",
+              action: "click->nk--tabs#select keydown->nk--tabs#navigate",
               nk__tabs_target: "tab"
-            },
-            id: tab_id(key, :tab),
-            role: "tab",
-            tabindex: default == key ? 0 : -1
-          )
-        ) do
-          text_or_block(text, &block)
-        end
-      end
+            }
+          }
+        )
+      ) { tab.label }
     end
 
-    def panel(key, **attrs)
-      builder do
-        div(
-          **mattr(
-            attrs,
+    def render_panel(tab, active_key:)
+      active = tab.key == active_key
+
+      div(
+        **slot_attributes(
+          :panel,
+          attributes: {
+            id: panel_id(tab),
+            role: "tabpanel",
             aria: {
-              hidden: (default != key).to_s,
-              labelledby: tab_id(key, :tab)
+              labelledby: tab_id(tab)
             },
-            class: panel_class,
             data: {
-              key:,
+              key: tab.key,
+              state: active ? "active" : "inactive",
               nk__tabs_target: "panel"
-            },
-            id: tab_id(key, :panel),
-            name: key,
-            role: "tabpanel"
-          )
-        ) do
-          yield
-        end
+            }
+          }
+        )
+      ) do
+        render(tab.content)
       end
     end
 
-    private
+    def resolve_active_key
+      enabled_tabs = @tabs.reject(&:disabled)
+      raise ArgumentError, "Tabs requires at least one enabled tab" if enabled_tabs.empty?
+
+      return enabled_tabs.first.key unless default
+
+      selected = find_tab(default)
+      raise ArgumentError, "Default tab key #{default.inspect} is not declared" unless selected
+      raise ArgumentError, "Default tab #{default.inspect} cannot be disabled" if selected.disabled
+
+      selected.key
+    end
+
+    def root_attributes_for(active_key)
+      attributes = root_attributes
+
+      attributes.merge(
+        data: attributes.fetch(:data).merge(nk__tabs_active_value: active_key)
+      )
+    end
 
-    def tab_id(key, suffix)
-      "#{id}-#{key}-#{suffix}"
+    def tab_id(tab)
+      "#{identifier}-#{tab.key}-tab"
     end
 
-    def base_class
-      "w-full"
+    def panel_id(tab)
+      "#{identifier}-#{tab.key}-panel"
     end
 
-    def tabs_class
-      "flex gap-4 border-b h-10"
+    def find_tab(key)
+      @tabs.find { |tab| tab.key == key }
     end
 
-    def tab_class
-      "border-b-2 border-transparent hover:border-primary focus-visible:border-primary cursor-pointer text-muted-content aria-[selected=true]:text-foreground font-medium aria-[selected=true]:border-primary -mb-px px-2"
+    def ensure_collecting!
+      return if @collecting
+
+      raise ArgumentError, "Tabs must be declared inside the render block"
+    end
+
+    def validate_label!(value)
+      return value if value.is_a?(String) && value.present?
+
+      raise ArgumentError, "Tabs labels must be non-blank Strings"
     end
 
-    def panel_class
-      "aria-[hidden=true]:hidden py-4"
+    def validate_boolean!(name, value)
+      return value if value == true || value == false
+
+      raise ArgumentError, "Tabs #{name} must be true or false"
+    end
+
+    def component_id(value)
+      return value if value.is_a?(String) && value.present? && !value.match?(/\s/)
+
+      raise ArgumentError, "Tabs id must be a non-blank String without whitespace"
     end
   end
 end

data/app/components/nitro_kit/textarea.rb

@@ -2,29 +2,100 @@
 
 module NitroKit
   class Textarea < Component
-    def initialize(value: nil, **attrs)
+    WRAPS = %i[soft hard off].freeze
+    OWNED_ATTRIBUTES = %i[
+      id name value placeholder disabled readonly required autocomplete rows cols minlength
+      maxlength wrap
+    ].freeze
+
+    def initialize(
+      id: nil,
+      name: nil,
+      value: nil,
+      placeholder: nil,
+      disabled: false,
+      readonly: false,
+      required: false,
+      autocomplete: nil,
+      rows: nil,
+      cols: nil,
+      minlength: nil,
+      maxlength: nil,
+      wrap: nil,
+      html: {},
+      aria: {},
+      data: {},
+      desperately_need_a_class: nil
+    )
       @value = value
+      disabled = validate_boolean!(:disabled, disabled)
+      readonly = validate_boolean!(:readonly, readonly)
+      required = validate_boolean!(:required, required)
+      rows = validate_positive_integer!(:rows, rows)
+      cols = validate_positive_integer!(:cols, cols)
+      minlength = validate_non_negative_integer!(:minlength, minlength)
+      maxlength = validate_non_negative_integer!(:maxlength, maxlength)
+      if minlength && maxlength && minlength > maxlength
+        raise ArgumentError, "minlength cannot exceed maxlength"
+      end
+      wrap = validate_choice!(:wrap, wrap.to_s.to_sym, WRAPS) unless wrap.nil?
+      reject_owned_attributes!(html)
 
       super(
-        attrs,
-        class: default_class
+        component: :textarea,
+        attributes: {
+          id:,
+          name:,
+          placeholder:,
+          disabled:,
+          readonly:,
+          required:,
+          autocomplete:,
+          rows:,
+          cols:,
+          minlength:,
+          maxlength:,
+          wrap:
+        }.compact,
+        html:,
+        aria:,
+        data:,
+        desperately_need_a_class:
       )
     end
 
     attr_reader :value
 
     def view_template
-      textarea(**attrs) { plain(value) }
+      textarea(**root_attributes) { plain(value.to_s) }
     end
 
     private
 
-    def default_class
-      [
-        "rounded-md border bg-background border-border text-base px-3 py-2",
-        # Focus
-        "focus:outline-none ring-ring ring-offset-2 ring-offset-background focus-visible:ring-2"
-      ]
+    def reject_owned_attributes!(html)
+      return unless html.is_a?(Hash)
+
+      html.each_key do |key|
+        normalized = key.to_s.downcase.tr("_", "-")
+        owned = OWNED_ATTRIBUTES.find { |name| name.to_s.tr("_", "-") == normalized }
+        next unless owned
+
+        raise ArgumentError, "#{normalized} is owned by Textarea; pass #{owned}: as a keyword"
+      end
+    end
+
+    def validate_positive_integer!(name, value)
+      return if value.nil?
+      return value if value.is_a?(Integer) && value.positive?
+
+      raise ArgumentError, "#{name} must be a positive Integer"
+    end
+
+    def validate_non_negative_integer!(name, value)
+      return if value.nil?
+      return value if value.is_a?(Integer) && value >= 0
+
+      raise ArgumentError, "#{name} must be a non-negative Integer"
     end
   end
 end